adva-categories 0.0.3 → 0.0.4

data/app/controllers/admin/categories_controller.rb

@@ -0,0 +1,4 @@
+class Admin::CategoriesController < Admin::BaseController
+  belongs_to :site
+  belongs_to :section
+end

data/app/controllers/base_controller_slice.rb

@@ -0,0 +1,15 @@
+require_dependency 'base_controller'
+
+BaseController.class_eval do
+  include do
+    def collection
+      params[:category_id] ? super.categorized(params[:category_id]) : super
+    end
+
+    def category
+      params[:category_id] ? Category.find(params[:category_id]) : nil
+    end
+  end
+
+  helper_method :category
+end

data/app/helpers/url_helper_slice.rb

@@ -0,0 +1,11 @@
+require_dependency 'url_helper'
+
+UrlHelper.module_eval do
+  include do
+    def public_url_for(resources, options = {})
+      options[:category_id] = resources.pop.id if resources.last.class.name == 'Category'
+      super
+    end
+  end
+end
+

data/app/models/categorization.rb

@@ -0,0 +1,5 @@
+class Categorization < ActiveRecord::Base
+  belongs_to :category
+  accepts_nested_attributes_for :category
+end
+

data/app/models/category.rb

@@ -0,0 +1,13 @@
+class Category < ActiveRecord::Base
+  belongs_to :section
+  validates_presence_of :section, :name
+
+  acts_as_nested_set :scope => :section_id
+  has_slug :scope => :section_id
+
+  class << self
+    def categorizable(table)
+      Category.has_many_polymorphs :categorizables, :through => :categorizations, :foreign_key => 'category_id', :from => [table]
+    end
+  end
+end

data/app/models/content_slice.rb

@@ -0,0 +1,2 @@
+Content.categorizable
+

data/app/models/section_slice.rb

@@ -0,0 +1,4 @@
+Section.class_eval do
+  has_many :categories, :foreign_key => :section_id
+  accepts_nested_attributes_for :categories
+end

data/app/views/admin/categories/_form.html.rb

@@ -0,0 +1,17 @@
+class Admin::Categories::Form < Adva::View::Form
+  include do
+    def fields
+      fieldset do
+        form.input :name
+      end
+    end
+
+    def sidebar
+      tab :options do
+        form.input :slug
+      end
+    end
+  end
+end
+
+

data/app/views/admin/categories/_menu.html.rb

@@ -0,0 +1,21 @@
+class Admin::Categories::Menu < Adva::View::Menu::Admin::Actions
+  include do
+    def main
+      parent_resource_label
+      index
+      edit_parent
+    end
+
+    def right
+      collection? ? new : destroy
+      reorder if index? && collection.size > 1
+    end
+
+    protected
+
+      def reorder
+        super( :'data-resource_type' => 'section', :'data-sortable_type' => 'categories')
+      end
+  end
+end
+

data/app/views/admin/categories/edit.html.rb

@@ -0,0 +1,9 @@
+class Admin::Categories::Edit < Adva::View::Form
+  include do
+    def to_html
+      h2 :'.title'
+      render :partial => 'form'
+    end
+  end
+end
+

data/app/views/admin/categories/index.html.rb

@@ -0,0 +1,20 @@
+class Admin::Categories::Index < Minimal::Template
+  include do
+    def to_html
+    	table_for collection, :class => 'categories list tree' do |t|
+    		t.column :category, :actions
+
+    		t.row do |r, category|
+          r.options[:id] = dom_id(category)
+          r.options[:class] = "level_#{category.level.to_i}"
+          r.cell capture { link_to_edit(category.name, category) }
+    			r.cell links_to_actions([:edit, :destroy], category)
+    		end
+
+    		t.empty :p, :class => 'categories list empty' do
+          self.t(:'.empty', :link => capture { link_to(:'.create_item', new_path(:category)) }).html_safe
+    		end
+    	end
+    end
+  end
+end

data/app/views/admin/categories/new.html.rb

@@ -0,0 +1,10 @@
+class Admin::Categories::New < Adva::View::Form
+  include do
+    def to_html
+      h2 :'.title'
+      render :partial => 'form'
+    end
+  end
+end
+
+

data/config/locales/en.yml

@@ -0,0 +1,32 @@
+en:
+  menu:
+    categories: Categories
+  columns:
+    category: Category
+    actions:
+  categories:
+    columns:
+      category: Category
+      actions:
+  admin:
+    categories:
+      # menu:
+      #   index: Categories
+      #   products: Products
+      #   new: New Category
+      #   edit_parent: Settings
+      #   destroy: Delete
+      #   reorder: Reorder
+      #   confirm_destroy: Do you really want to delete this category?
+      index:
+        create_item: Create Category
+        edit: Edit
+        destroy: Delete
+        confirm_destroy: Do you really want to delete this category?
+        empty: "There are no categories. %{link}"
+      new:
+        title: Create a Category
+      edit:
+        title: Edit Category
+    tabs:
+      categories: Categories

data/config/redirects.rb

@@ -0,0 +1,4 @@
+Adva::Registry.set :redirect, {
+  'admin/categories#create' => lambda { |c| c.edit_url },
+  'admin/categories#update' => lambda { |c| c.edit_url }
+}

data/config/routes.rb

@@ -0,0 +1,13 @@
+require 'adva/routing_filters/categories'
+
+Rails.application.routes.draw do
+  filter :categories
+
+  namespace :admin do
+    resources :sites do
+      resources :sections do
+        resources :categories
+      end
+    end
+  end
+end

data/lib/adva/active_record/categorizable.rb

@@ -0,0 +1,26 @@
+module Adva
+  module Categorizable
+    def categorizable
+      unless categorizable?
+        Category.categorizable(name.underscore.pluralize.to_sym)
+        has_many :categories, :through => :categorizations, :as => :categorizable
+        accepts_nested_attributes_for :categorizations, :allow_destroy => true
+        extend ClassMethods
+      end
+    end
+
+    def categorizable?
+      singleton_class.included_modules.include?(ClassMethods)
+    end
+
+    module ClassMethods
+      def categorized(category_id)
+        category     = Category.find(category_id)
+        category_ids = category.self_and_descendants.map(&:id)
+        includes(:categorizations).where(:categorizations => { :category_id => category_ids })
+      end
+    end
+
+    ActiveRecord::Base.extend(self)
+  end
+end

data/lib/adva/categories.rb

@@ -0,0 +1,13 @@
+require 'adva/core'
+require 'adva/active_record/categorizable'
+require 'adva/views/categories_tab'
+
+module Adva
+  class Categories < ::Rails::Engine
+    include Adva::Engine
+
+    initializer 'adva-categories.configure_routing_filters' do
+      RoutingFilter::SectionRoot.anchors << 'categories'
+    end
+  end
+end

data/lib/adva/routing_filters/categories.rb

@@ -0,0 +1,81 @@
+require 'routing_filter'
+
+module RoutingFilter
+  class Categories < Filter
+    cattr_accessor :default_port
+    self.default_port = '80'
+
+    cattr_accessor :exclude
+    self.exclude = %r(^/admin)
+
+    def around_recognize(path, env, &block)
+      # p "#{self.class.name}: #{path}"
+      unless excluded?(path)
+        category_id = extract_category_id(env, path)
+        yield.tap do |params|
+          params[:category_id] = category_id if category_id
+        end
+      else
+        yield
+      end
+    end
+
+    def around_generate(params, &block)
+      category_id = params.delete('category_id') || params.delete(:category_id)
+      yield.tap do |path|
+        # p "#{self.class.name}: #{path}"
+        insert_category_path(path, category_id) if !excluded?(path) && category_id
+      end
+    end
+
+    protected
+
+      def excluded?(path)
+        path =~ exclude
+      end
+
+      def extract_category_id(env, path)
+        if section = section_for(env, path) and path =~ recognition_pattern(section)
+          if category = section.categories.where(:path => $2).first
+            path.gsub!("#{$1}#{$2}", '')
+            path.replace('/') if path.blank?
+            category.id.to_s
+          end
+        end
+      end
+
+      def recognition_pattern(section)
+        paths = section.categories.map(&:path).reject(&:blank?)
+        paths = paths.sort { |a, b| b.size <=> a.size }.join('|')
+        paths.empty? ? %r(^$) : %r(^.*(/categories/)(#{paths})(?=/|\.|\?|$))
+      end
+
+      def insert_category_path(path, category_id)
+        category = Category.find(category_id)
+        if path =~ section_pattern
+          path.sub!("/#{$1}/#{$2}", "/#{$1}/#{$2}/categories/#{category.path}")
+        elsif category.section.root?
+          path.sub!(%r(^/), "/categories/#{category.path}")
+        end
+      end
+
+      def section_pattern
+        types = Section.types.map { |type| type.downcase.pluralize }.join('|')
+        %r(/(sections|#{types})/(\d+)(?=/|\.|\?|$))
+      end
+
+      def section_for(env, path)
+        if path =~ section_pattern
+          Section.find($2)
+        elsif path =~ %r(^/categories/\w+) && site = Site.by_host(host(env))
+          site.sections.root
+        end
+      end
+
+      def host(env)
+        host, port = env.values_at('SERVER_NAME', 'SERVER_PORT')
+        port == default_port ? host : [host, port].compact.join(':')
+      end
+  end
+end
+

data/lib/adva/views/categories_tab.rb

@@ -0,0 +1,14 @@
+# this should rather be a code slice, shouldn't it? but slices don't support files
+# that aren't loadable through require_dependency
+
+require 'adva/view/form'
+
+Adva::View::Form.class_eval do
+  def categories_tab(categories)
+    tab :categories do
+      fieldset do
+        form.has_many_through_collection_check_boxes(:categorizations, categories, :name)
+      end
+    end if categories.present?
+  end
+end

data/lib/adva-categories.rb

@@ -0,0 +1 @@
+require 'adva/categories'

data/lib/adva_categories/version.rb

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

data/lib/testing/factories.rb

@@ -0,0 +1,4 @@
+Factory.define :category do |f|
+  f.section { Section.first || Factory(:section) }
+  f.name 'Category'
+end

data/lib/testing/paths.rb

@@ -0,0 +1,15 @@
+module Adva::Categories::Paths
+  def path_to(page)
+    case page
+    when /^the admin "([^"]*)" section categories page$/
+      site = Site.first
+      section = Section.where(:name => $1).first || raise("could not find section named #{$1}")
+      polymorphic_path([:admin, site, section, :categories])
+    else
+      super
+    end
+  end
+end
+
+World(Adva::Categories::Paths)
+

data/lib/testing/step_definitions.rb

@@ -0,0 +1,21 @@
+When /^I drag the category "([^"]*)" below the category "([^"]*)"$/ do |category, target|
+  category = Category.find_by_name(category)
+  target = Category.find_by_name(target)
+  section = Section.first
+  put(admin_site_section_path(section.site, section), {
+    :section   => { :categories_attributes => [{ :id => category.id, :left_id => target.id }] },
+    :return_to => @request.url
+  })
+  follow_redirect!
+end
+
+Then /^the ([\w]+) (name|title)d "([^"]+)" should be categorized as "([^"]+)"$/ do |model, attribute, value, category|
+  record = model.classify.constantize.where(attribute => value).first
+  assert record.categories.map(&:name).include?(category), "expected #{record.inspect} to be categorized as #{category}"
+end
+
+Then /^the ([\w]+) (name|title)d "([^"]+)" should not be categorized as "([^"]+)"$/ do |model, attribute, value, category|
+  record = model.classify.constantize.where(attribute => value).first
+  assert !record.categories.map(&:name).include?(category), "expected #{record.inspect} not to be categorized as #{category}"
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: adva-categories
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Ingo Weiss
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-19 00:00:00 +01:00
+date: 2010-12-03 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,7 +42,30 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/bundler/repository.rb
+- app/controllers/admin/categories_controller.rb
+- app/controllers/base_controller_slice.rb
+- app/helpers/url_helper_slice.rb
+- app/views/admin/categories/index.html.rb
+- app/views/admin/categories/edit.html.rb
+- app/views/admin/categories/new.html.rb
+- app/views/admin/categories/_form.html.rb
+- app/views/admin/categories/_menu.html.rb
+- app/models/content_slice.rb
+- app/models/category.rb
+- app/models/categorization.rb
+- app/models/section_slice.rb
+- config/redirects.rb
+- config/routes.rb
+- config/locales/en.yml
+- lib/adva-categories.rb
+- lib/adva_categories/version.rb
+- lib/adva/categories.rb
+- lib/adva/active_record/categorizable.rb
+- lib/adva/routing_filters/categories.rb
+- lib/adva/views/categories_tab.rb
+- lib/testing/factories.rb
+- lib/testing/paths.rb
+- lib/testing/step_definitions.rb
 has_rdoc: true
 homepage: http://github.com/svenfuchs/adva-cms2
 licenses: []

data/lib/bundler/repository.rb

@@ -1,118 +0,0 @@
-require 'pathname'
-
-# Bundler gemfile support for local/remote workspaces/repositories for work in
-# development teams.
-#
-# Usage:
-#
-#   # define paths to be searched for repositories:
-#   workspace '~/.projects ~/Development/{projects,work}'
-#
-#   # define developer preferences for using local or remote repositories (uses ENV['user']):
-#   developer :sven, :prefer => :local
-#
-#   # define repositories to be used for particular gems:
-#   adva_cms  = repository('adva-cms2', :git => 'git@github.com:svenfuchs/adva-cms2.git', :ref => 'c2af0de')
-#   adva_shop = repository('adva-shop', :source => :local)
-#
-#   # now use repositories to define gems:
-#   adva_cms.gem  'adva-core'
-#   adva_shop.gem 'adva-catalog'
-#
-#   # The gem definition will now be proxied to Bundler with arguments according
-#   # to the setup defined earlier. E.g. as:
-#
-#   gem 'adva-core', :path => 'Development/projects/adva-cms2/adva-core'                 # for developer 'sven'
-#   gem 'adva-core', :git => 'git@github.com:svenfuchs/adva-cms2.git', :ref => 'c2af0de' # for other developers
-#   gem 'adva-catalog', :path => 'Development/projects/adva-shop/adva-catalog'           # for all developers
-#
-#  One can also set an environment variable FORCE_REMOTE which will force remote
-#  repositories to be used *except* when a repository was defined with :source => :local
-#  which always forces the local repository to be used.
-#
-class Repository
-  class << self
-    def paths
-      @paths ||= []
-    end
-
-    def path(*paths)
-      paths.join(' ').split(' ').each do |path|
-        self.paths.concat(Pathname.glob(File.expand_path(path)))
-      end
-    end
-
-    def developer(name, preferences)
-      developers[name] = preferences
-      workspaces(preferences[:workspace])
-    end
-
-    def current_developer
-      developers[ENV['USER'].to_sym] || {}
-    end
-
-    def developers(developers = nil)
-      @developers ||= {}
-    end
-  end
-
-  class Gem < Array
-    def initialize(name, repository)
-      if repository.local?
-        sub_path = repository.path.join(name)
-        super([name, { :path => sub_path.exist? ? sub_path.to_s : repository.path.to_s }])
-      else
-        super([name, repository.options.dup])
-      end
-    end
-  end
-
-  attr_reader :bundler, :name, :options, :source
-
-  def initialize(bundler, name, options)
-    @bundler = bundler
-    @name    = name
-    @source  = options.delete(:source)
-    @options = options
-  end
-
-  def gem(name)
-    bundler.gem(*Gem.new(name, self))
-  end
-
-  def local?
-    source == :local # && path
-  end
-
-  def source
-    @source ||= forced_source || preferred_source || :remote
-  end
-
-  def forced_source
-    :remote if ENV['FORCE_REMOTE']
-  end
-
-  def preferred_source
-    self.class.current_developer[:prefer] || self.class.current_developer[name.to_sym]
-  end
-
-  def path
-    @path ||= begin
-      path = self.class.paths.detect { |path| path.join(name).exist? }
-      path ? path.join(name) : Pathname.new('.')
-    end
-  end
-end
-
-def workspace(*paths)
-  Repository.path(*paths)
-end
-alias :workspaces :workspace
-
-def developer(name, preferences)
-  Repository.developer(name, preferences)
-end
-
-def repository(*args)
-  Repository.new(self, *args)
-end