adva_cms 0.0.1

data/vendor/gems/table_builder/test/test_helper.rb

@@ -0,0 +1,49 @@
+$: << File.dirname(__FILE__) + "/../lib"
+
+require 'rubygems'
+require 'activesupport'
+require 'actionpack'
+require 'action_controller'
+require 'action_view'
+require 'action_view/test_case'
+require 'table_builder'
+
+class Test::Unit::TestCase
+  include ActionController::Assertions::SelectorAssertions
+
+  def assert_html(html, *args, &block)
+    assert_select(HTML::Document.new(html).root, *args, &block)
+  end
+end
+
+module TableBuilder
+  module TableTestHelper
+    def setup
+      @scope = TableBuilder.options[:i18n_scope]
+    end
+  
+    def teardown
+      TableBuilder.options[:i18n_scope] = @scope
+    end
+    
+    def build_column(name, options = {})
+      Column.new(nil, name, options)
+    end
+  
+    def build_table(*columns)
+      columns = [build_column('foo'), build_column('bar')] if columns.empty?
+      table = Table.new(%w(foo bar))
+      table.instance_variable_set(:@columns, columns)
+      columns.each { |column| column.instance_variable_set(:@table, table) }
+      table
+    end
+    
+    def build_body(*columns)
+      Body.new(build_table(*columns))
+    end
+    
+    def build_body_row(*columns)
+      Row.new(build_body(*columns))
+    end
+  end
+end

data/vendor/gems/tags/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/vendor/gems/tags/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tags.gemspec
+gemspec

data/vendor/gems/tags/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Micah Geisel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/gems/tags/README.md

@@ -0,0 +1,29 @@
+# Tags
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tags'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tags
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/vendor/gems/tags/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/vendor/gems/tags/lib/breadcrumbs.rb

@@ -0,0 +1,13 @@
+class Breadcrumbs < Tags::Tag
+  self.tag_name = :ul
+  
+  def initialize(items)
+    super :id => 'breadcrumbs'
+    @items = items
+  end
+
+  def content
+    @items[0, @items.size - 1].map { |item| Tags::Li.new(item.content).render }.join + 
+    Tags::Li.new(@items.last.text, :class => 'last').render
+  end
+end

data/vendor/gems/tags/lib/menu.rb

@@ -0,0 +1,179 @@
+require 'menu/builder'
+
+module Menu
+  class Base < Tags::Tag
+    class << self
+      attr_writer :definitions
+      def definitions
+        @definitions ||= []
+      end
+
+      def define(*args, &block)
+        definitions << [block, args.extract_options!]
+      end
+    end
+
+    attr_accessor :key, :content, :namespace, :url, :active, :parent, :children
+    attr_writer :activates, :breadcrumbs
+
+    def initialize(key = nil, options = {})
+      super(options)
+      @key = key || self.class.name.demodulize.underscore.sub('_menu', '').to_sym
+      @breadcrumbs = []
+		  [:id, :content, :text, :url].each { |key| instance_variable_set(:"@#{key}", options.delete(key)) }
+		  @url.sub!(/\?.*/, '') if @url
+    end
+
+    def find(key)
+      child = children.detect { |item| item.key == key } and return child
+      children.each { |child| child = child.find(key) and return child }
+      nil
+    end
+
+    def [](*keys)
+      return self if keys.empty?
+      keys = keys.first.to_s.split('.').map(&:to_sym) + keys[1, keys.size] if keys.first
+      key = keys.shift
+      child = children.detect { |item| item.key == key } or raise "can not find item #{key.inspect}"
+      (child.nil? || keys.empty?) ? child : child[*keys]
+    end
+
+    def definitions
+      self.class.definitions
+    end
+
+    def activates
+      @activates ||= parent
+    end
+
+    def id
+      @id ||= @key
+    end
+
+    def namespace
+      @namespace or parent.try(:namespace)
+    end
+
+    def breadcrumbs
+      (activates ? activates.breadcrumbs : []) + @breadcrumbs
+    end
+
+    def activation_path
+      [self] + Array(activates ? activates.activation_path : nil).compact
+    end
+
+    def activate(path)
+      path.sub! %r((\?|/pages/.*)), ''
+      url == path ? activation_path.each { |item| item.active = self } : self.active = false
+      children.each { |child| child.activate(path) }
+    end
+
+    def render(options = {})
+      super(options) { |html| children.each { |child| html << child.render } }
+    end
+
+    def reset
+      self.active = false
+      children.each(&:reset)
+    end
+
+    def build(scope = nil)
+      @built = true
+      Builder.new(self, scope, definitions)
+      populate(scope)
+      activate(scope.request.path) if scope
+      self
+    end
+
+    def populate(scope)
+      children.each { |child| child.populate(scope) if child.respond_to?(:populate) }
+    end
+
+    def build?
+      !@built && !definitions.empty?
+    end
+  end
+
+  class Item < Base
+    def breadcrumbs
+      breadcrumbs = Array(activates.breadcrumbs).compact
+      breadcrumbs << self.dup unless breadcrumbs.map(&:key).include?(key)
+      breadcrumbs
+    end
+
+    def render
+	    tag = Tags::Li.new(content, :class => 'item')
+	    tag.add_class('active') if active
+	    tag.render
+    end
+
+    def text
+      @text ||= key.is_a?(Symbol) ? I18n.t(key, :scope => :'adva.titles') : key
+    end
+
+	  def content
+	    @content ||= url ? Tags::A.new(text, :id => id, :href => url).render : Tags::Span.new(text).render
+    end
+  end
+
+  class Menu < Base
+    self.tag_name = 'ul'
+  end
+
+  class Group < Base
+    self.tag_name = 'div'
+    
+    # attr_accessor :wrap
+    # 
+    # def initialize(key = nil, options = {})
+    #   @wrap = options[:wrap]
+    # end
+    # 
+    # def render
+    # end
+  end
+
+	class SectionsMenu < Item
+	  attr_reader :sections
+
+	  def initialize(*args)
+	    super
+	    @sections = []
+    end
+
+    def populate(scope)
+      scope.instance_eval(&@options[:populate]).each do |s|
+	      @sections << Base.new(s.title, :level => s.level, :url => scope.url_for([:admin, s.site, s, :contents])) unless s.new_record?
+      end
+    end
+
+    def breadcrumbs
+      Array(activates.breadcrumbs).compact + [item, active_section].compact
+    end
+
+    def activate(path)
+      super
+      path = path =~ %r((^.*/sections/[\d]+)) && $1 or return
+      @sections.each { |section| section.active = self if section.url.starts_with?(path) }
+    end
+
+    def item
+      Item.new key, :text => @text, :content => @content, :url => @url
+    end
+
+    def active_section
+      section = sections.detect { |section| section.active }
+      section && Item.new(:section, :text => section.id, :url => @url)
+    end
+
+    def content
+      super + Tags::Ul.new(:id => 'sections_menu').render do |html|
+        sections.each do |section|
+          section.add_class("level_#{[section.level, 10].min}" + (section.active ? ' active' : ''))
+          link = Tags::A.new(section.id, :href => section.url, :class => section.options[:class])
+          html << Tags::Li.new(link.render).render
+        end
+      end
+    end
+  end
+end

data/vendor/gems/tags/lib/menu/builder.rb

@@ -0,0 +1,74 @@
+module Menu
+  class Builder
+    attr_reader :object, :scope
+
+    def initialize(object, scope = nil, definitions = nil)
+      @object = object
+      @scope = scope
+      
+      assign_ivars!(scope) if scope
+
+      Array(definitions).each do |block, options|
+        self.options(options) if options
+        instance_eval(&block)
+      end
+    end
+
+    def assign_ivars!(scope)
+      scope.assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+      vars = scope.controller.instance_variable_names
+      vars.each { |name| instance_variable_set(name, scope.controller.instance_variable_get(name)) unless name == '@scope' }
+    end
+  
+    def id(key)
+      object.key = key
+    end
+  
+    def options(options)
+      object.options ||= {}
+      object.options.update(options)
+    end
+    
+    def parent(parent)
+      parent.children << object
+    end
+    
+    def activates(activates)
+      object.activates = activates
+    end
+    
+    def menu(key, options = {}, &block)
+      type = options.delete(:type) || Menu
+      menu = type.new(key, options)
+      object.children << menu
+      Builder.new(menu, scope, block || type.definitions).object
+    end
+
+    def item(key, options = {})
+      action, resource = *options.values_at(:action, :resource)
+      namespace = options.delete(:namespace) || object.namespace
+      if action && resource
+        url = resource_url(action, resource, :namespace => namespace, :only_path => true)
+        type, resource = *resource.reverse if resource.is_a?(Array)
+        type = normalize_resource_type(action, type, resource)
+        options.update :id => :"#{action}_#{type}", :url => url
+      end
+      type = options.delete(:type) || Item
+      object.children << item = type.new(key, options)
+    end
+    
+    def namespace(namespace)
+      object.namespace = namespace
+    end
+
+    def breadcrumb(key, options = {})
+      type = options.delete(:type) || Item
+      object.instance_variable_get(:@breadcrumbs) << type.new(key, options)
+    end
+    
+    def method_missing(method, *args, &block)
+      return scope.send(method, *args, &block) if scope.respond_to?(method)
+      super
+    end
+  end
+end

data/vendor/gems/tags/lib/tags.rb

@@ -0,0 +1,7 @@
+require "tags/version"
+require 'tags/tag'
+require 'menu'
+require 'breadcrumbs'
+
+module Tags
+end

data/vendor/gems/tags/lib/tags/tag.rb

@@ -0,0 +1,125 @@
+module Tags
+  class Node
+    attr_accessor :options, :children, :parent
+
+    def initialize(options = nil)
+      @options = options || {}
+      @children = TagsList.new(self)
+      @level = options.delete(:level)
+    end
+
+    def root
+      parent ? parent.root : self
+    end
+
+	  def level
+	    @level ||= parents.size
+    end
+
+    def parents
+      parent ? [parent] + (parent.try(:parents) || []) : []
+    end
+
+    def self_and_parents
+      [self] + parents
+    end
+
+    protected
+
+      def insert_at_position(child, before, after)
+        index = 0  if before == :first
+        index = -1 if after == :last
+
+        index ||= if found = before && children.detect { |o| o.id == before }
+          children.index(found)
+        elsif found = after && children.detect { |o| o.id == after }
+          children.index(found) + 1
+        end
+        index ||= -1
+
+        children.insert(index, child)
+        child
+      end
+
+      def add_class(class_name)
+        unless class_name.blank?
+          options[:class] ||= ''
+          options[:class] = options[:class].split(' ').push(class_name).uniq.join(' ')
+        end
+      end
+  end
+
+  class TagsList < Array
+    attr_reader :owner
+    def initialize(owner)
+      @owner = owner
+    end
+
+    def <<(tag)
+      tag.parent.children.delete(tag) if tag.parent
+      tag.parent = owner
+      super
+    end
+
+    def insert(index, tag)
+      tag.parent = owner
+      super
+    end
+  end
+
+  class Tag < Node
+    include ActionView::Helpers::TagHelper
+
+    attr_accessor :content
+
+    class << self
+      attr_writer :tag_name
+      def tag_name
+        @tag_name || name.demodulize.underscore.to_sym
+      end
+    end
+
+    def initialize(*args)
+      super(args.extract_options!)
+      self.content = args.shift
+    end
+
+    def content=(content)
+      @content = content.is_a?(Symbol) ? I18n.t(content) : content
+    end
+
+    def tag_name
+      self.class.tag_name
+    end
+
+    def render(options = {})
+      content = (self.content || '').dup
+      yield(content) if block_given?
+      content_tag(tag_name, content.to_s.html_safe, self.options.merge(options))
+    end
+
+    protected
+      def lf(str)
+        "\n#{str}\n"
+      end
+
+      def indent(str)
+        str.gsub(/^/, "  ")
+      end
+  end
+
+	class A < Tag
+	end
+
+	class Span < Tag
+	end
+
+	class Div < Tag
+	end
+
+	class Ul < Tag
+	end
+
+	class Li < Tag
+	end
+end