adva-markup 0.0.3 → 0.0.4

data/app/models/content_slice.rb

@@ -0,0 +1,9 @@
+require_dependency 'content'
+
+Content.class_eval do
+  filters :body
+
+  def filter
+    read_attribute(:filter) || (section.respond_to?(:default_filter) ? section.default_filter : nil)
+  end
+end

data/app/models/section_slice.rb

@@ -0,0 +1,6 @@
+require_dependency 'section'
+
+Section.class_eval do
+  has_option :default_filter
+end
+

data/app/views/admin/blogs/_form_slice.html.rb

@@ -0,0 +1,14 @@
+require_dependency 'admin/blogs/_form.html'
+
+Admin::Blogs::Form.class_eval do
+  include do
+    def fields
+      super
+      fieldset do
+        column do
+          form.input :default_filter, :as => :select, :collection => Adva::Markup.options
+        end
+      end
+    end
+  end
+end

data/app/views/admin/posts/_form_slice.html.rb

@@ -0,0 +1,10 @@
+require_dependency 'admin/posts/_form.html.rb'
+
+Admin::Posts::Form.include do
+  def sidebar
+    super
+    tab :options do
+      form.input :filter, :as => :select, :collection => Adva::Markup.options
+    end
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,2 @@
+en:
+  markup: ""

data/config/redirects.rb

@@ -0,0 +1,3 @@
+# Adva::Registry.set :redirect, {
+#   'controller#action' => lambda { |controller| controller.show_url }
+# }

data/config/routes.rb

@@ -0,0 +1,3 @@
+# Rails.application.routes.draw do
+#   resource :markup
+# end

data/lib/adva-markup.rb

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

data/lib/adva/markup.rb

@@ -0,0 +1,48 @@
+require 'adva/core'
+require 'RedCloth'
+require 'rdiscount'
+
+ERB::Util.send(:undef_method, :t) # wtf, redcloth!
+
+module Adva
+  class Markup < ::Rails::Engine
+    include Adva::Engine
+
+    autoload :ActionController, 'adva/markup/action_controller'
+    autoload :ActiveRecord, 'adva/markup/active_record'
+
+    mattr_accessor :filters
+    self.filters = {
+      :markdown => 'RDiscount',
+      :textile  => 'RedCloth'
+    }
+
+    class << self
+      def apply(name, markup)
+        if filter = self.filter(name)
+          filter.new(markup).to_html
+        end
+      end
+
+      def filter(name)
+        filters[name.to_sym].constantize if name.present? && filters[name.to_sym]
+      end
+
+      def keys
+        @keys ||= filters.keys.map(&:to_s).sort
+      end
+
+      def names
+        @names ||= keys.map { |key| key.titleize }
+      end
+
+      def options
+        @options ||= Hash[*names.zip(keys).flatten]
+      end
+    end
+  end
+end
+
+ActionController::Base.extend(Adva::Markup::ActionController::ActMacro)
+ActiveRecord::Base.extend(Adva::Markup::ActiveRecord::ActMacro)
+

data/lib/adva/markup/action_controller.rb

@@ -0,0 +1,38 @@
+module Adva
+  class Markup
+    module ActionController
+      module ActMacro
+        def filtered_attributes(*models)
+          options = models.extract_options!
+          options[:models] = models.map(&:to_s).map(&:camelize)
+          options[:only]   = Array(options[:only]).map(&:to_sym)
+          options[:except] = Array(options[:except]).map(&:to_sym)
+
+          class_inheritable_accessor :filtered_attribute_options
+          self.filtered_attribute_options = options
+
+          include InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+        def render(*args)
+          options  = filtered_attribute_options
+          excluded = options[:except].include?(params[:action].to_sym)
+          included = options[:only].empty? || options[:only].include?(params[:action].to_sym)
+
+          !excluded && included ? with_filtered_attributes { super } : super
+        end
+
+        def with_filtered_attributes
+          models = filtered_attribute_options[:models].map(&:constantize)
+          models.each { |model| model.read_filtered_attributes = true }
+          yield.tap do
+            models.each { |model| model.read_filtered_attributes = false }
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/adva/markup/active_record.rb

@@ -0,0 +1,47 @@
+module Adva
+  class Markup
+    module ActiveRecord
+      module ActMacro
+        def filters(*attributes)
+          unless filters?
+            class_inheritable_accessor :filtered_attributes
+            class_inheritable_accessor :read_filtered_attributes
+
+            self.filtered_attributes = []
+            self.read_filtered_attributes = false
+
+            before_save :filter_attributes!
+            include InstanceMethods
+          end
+
+          self.filtered_attributes += attributes
+          include attribute_readers_module(attributes)
+        end
+
+        def attribute_readers_module(attributes)
+          Module.new.tap do |readers|
+            attributes.each do |name|
+              readers.module_eval <<-rb
+                def #{name}; read_filtered_attributes ? send(:#{name}_html) : super; end
+              rb
+            end
+          end
+        end
+
+        def filters?
+          included_modules.include?(InstanceMethods)
+        end
+      end
+
+      module InstanceMethods
+        def filter_attributes!
+          filtered_attributes.each do |name|
+            value = self.send(name)
+            value = Adva::Markup.apply(filter, value) if respond_to?(:filter) && filter
+            write_attribute(:"#{name}_html", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adva_markup/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: adva-markup
 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: 
 - Sven Fuchs
@@ -15,7 +15,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 
@@ -69,7 +69,18 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/bundler/repository.rb
+- app/views/admin/blogs/_form_slice.html.rb
+- app/views/admin/posts/_form_slice.html.rb
+- app/models/content_slice.rb
+- app/models/section_slice.rb
+- config/redirects.rb
+- config/routes.rb
+- config/locales/en.yml
+- lib/adva_markup/version.rb
+- lib/adva/markup.rb
+- lib/adva/markup/action_controller.rb
+- lib/adva/markup/active_record.rb
+- lib/adva-markup.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