adva_cms 0.0.1

data/vendor/gems/belongs_to_cacheable/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'active_record'
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+end
+
+require File.dirname(__FILE__) + '/../lib/active_record/belongs_to_cacheable.rb'
+require File.dirname(__FILE__) + '/../init.rb'
+
+name = "belongs_to_cacheable"
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/#{name}.spec.log")
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+module SpecHelper
+  class Article < ActiveRecord::Base
+    self.table_name = 'articles'
+    
+    unless table_exists?
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :articles, :force => true do |t|
+          t.string     :title
+          t.references :author, :polymorphic => true
+          t.string     :author_name
+          t.string     :author_email
+          t.references :last_author, :polymorphic => true
+          t.string     :last_author_name
+        end
+      end
+    end
+    
+    belongs_to_cacheable :author
+    belongs_to_cacheable :last_author
+  end
+  
+  class User < ActiveRecord::Base
+    self.table_name = 'users'
+    
+    unless table_exists?
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :users, :force => true do |t|
+          t.string     :name
+          t.string     :email
+          t.string     :url
+        end
+      end
+    end
+  end
+end

data/vendor/gems/filtered_column/.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/filtered_column/Gemfile

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

data/vendor/gems/filtered_column/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/filtered_column/README

@@ -0,0 +1,4 @@
+FilteredColumn
+==============
+
+Description goes here

data/vendor/gems/filtered_column/README.md

@@ -0,0 +1,29 @@
+# FilteredColumn
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'filtered_column'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install filtered_column
+
+## 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/filtered_column/Rakefile

@@ -0,0 +1,23 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the filtered_column plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the filtered_column plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FilteredColumn'
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/gems/filtered_column/filtered_column.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/filtered_column/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Micah Geisel"]
+  gem.email         = ["micah@botandrose.com"]
+  gem.description   = %q{TODO: Write a gem description}
+  gem.summary       = %q{TODO: Write a gem summary}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "filtered_column"
+  gem.require_paths = ["lib"]
+  gem.version       = FilteredColumn::VERSION
+end

data/vendor/gems/filtered_column/lib/filtered_column.rb

@@ -0,0 +1,17 @@
+require "filtered_column/version"
+require "filtered_column/processor"
+require "filtered_column/mixin"
+require "filtered_column/filters/base"
+require "filtered_column/macros/base"
+
+require "filtered_column/filters/smartypants_filter"
+require "filtered_column/filters/textile_filter"
+FilteredColumn.filters[:smartypants_filter] = FilteredColumn::Filters::SmartypantsFilter
+FilteredColumn.filters[:textile_filter] = FilteredColumn::Filters::TextileFilter
+
+# don't even bother until there are default macros
+#Dir["#{File.dirname(__FILE__)}/filtered_column/macros/*_macro.rb"].sort.each do |macro_name|
+#  FilteredColumn.macros.update(File.basename(macro_name).sub(/\.rb/, '').to_sym => nil)
+#end
+
+ActiveRecord::Base.send(:include, FilteredColumn::Mixin)

data/vendor/gems/filtered_column/lib/filtered_column/filters/base.rb

@@ -0,0 +1,28 @@
+module FilteredColumn
+  module Filters
+    class Base
+      class << self
+        def filter(text) text end
+        def escape(text) text end
+
+        def filter_name
+          set_name self.name.demodulize.gsub(/Filter$/, '')
+        end
+        
+        def set_name(name)
+          class << self; attr_reader :filter_name ; end
+          @filter_name = name
+        end
+        
+        def filter_key
+          set_key self.name.demodulize.underscore.to_sym
+        end
+        
+        def set_key(key)
+          class << self; attr_reader :filter_key ; end
+          @filter_key = key
+        end
+      end
+    end
+  end
+end

data/vendor/gems/filtered_column/lib/filtered_column/filters/smartypants_filter.rb

@@ -0,0 +1,14 @@
+module FilteredColumn
+  module Filters
+    class SmartypantsFilter < Base
+      set_name "Markdown with Smarty Pants"
+      def self.filter(text)
+        if Object.const_defined?(:BlueCloth) && Object.const_defined?(:RubyPants)
+          RubyPants.new(BlueCloth.new(text.gsub(%r{</?notextile>}, '')).to_html).to_html
+        else
+          text
+        end
+      end
+    end
+  end
+end

data/vendor/gems/filtered_column/lib/filtered_column/filters/textile_filter.rb

@@ -0,0 +1,13 @@
+module FilteredColumn
+  module Filters
+    class TextileFilter < Base
+      def self.filter(text)
+        Object.const_defined?("RedCloth") ? RedCloth.new(text).to_html : text
+      end
+      
+      def self.escape(text)
+        %(<notextile>#{text}</notextile>)
+      end
+    end
+  end
+end

data/vendor/gems/filtered_column/lib/filtered_column/macros/base.rb

@@ -0,0 +1,25 @@
+module FilteredColumn
+  module Macros
+    class Base
+      class << self
+        def macro_name
+          set_name self.name.demodulize.sub(/Macro$/, '')
+        end
+        
+        def set_name(name)
+          class << self; attr_reader :macro_name ; end
+          @macro_name = name
+        end
+        
+        def macro_key
+          set_key self.name.demodulize.underscore.to_sym
+        end
+        
+        def set_key(key)
+          class << self; attr_reader :macro_key ; end
+          @macro_key = key
+        end
+      end
+    end
+  end
+end

data/vendor/gems/filtered_column/lib/filtered_column/mixin.rb

@@ -0,0 +1,46 @@
+module FilteredColumn
+  module Mixin
+    def self.included(base)
+      base.extend(ActMethod)
+    end
+    
+    module ActMethod
+      # filtered_column :name, :title, :only => [ :textile_filter, :smartypants_filter ]
+      def filtered_column(*names)
+        unless included_modules.include?(InstanceMethods)
+          send :include, InstanceMethods
+          class_attribute :filtered_attributes, :filtered_options
+          before_save :process_filters
+        end
+        
+        options = names.last.is_a?(Hash) ? names.pop : {}
+        options[:only]   = [options[:only]].flatten.compact
+        options[:except] = [options[:except]].flatten.compact
+        names.each do |name|
+          (self.filtered_options    ||= {})[name] = options
+          (self.filtered_attributes ||= []) << name
+          define_method("#{name}_doc") do
+            class << self; attr_accessor "#{name}_doc"; end
+            instance_variable_set("@#{name}_doc", HTML::Document.new(send("#{name}_html")))
+          end
+        end
+      end
+
+      module InstanceMethods
+        protected
+          def process_filters
+            filtered_attributes.each do |attr_name|
+              send "#{attr_name}_html=", FilteredColumn::Processor.process_filter(filter_for_attribute(attr_name), send(attr_name).to_s.dup)
+            end
+          end
+           
+          def filter_for_attribute(attr_name)
+            return nil if filter.blank? ||
+              (!filtered_options[attr_name][:only].blank?   && !filtered_options[attr_name][:only].include?(filter.to_sym)) ||
+              (!filtered_options[attr_name][:except].blank? &&  filtered_options[attr_name][:except].include?(filter.to_sym))
+            filter
+          end
+      end
+    end
+  end
+end

data/vendor/gems/filtered_column/lib/filtered_column/processor.rb

@@ -0,0 +1,52 @@
+module FilteredColumn
+  @@filters = {}
+  @@macros  = {}
+  mattr_reader :filters, :macros
+
+  class Processor
+    @@patterns = [
+      /<(filter|macro|typo):([_a-zA-Z0-9]+)([^>]*)\/>/,
+      /<(filter|macro|typo):([_a-zA-Z0-9]+)([^>]*)>(.*?)<\/(filter|macro|typo):([_a-zA-Z0-9]+)>/m
+      ].freeze
+      
+    def self.process_filter(filter_name, text)
+      new(filter_name, text).filter
+    end
+    
+    def initialize(filter_name, text)
+      @filter = FilteredColumn.filters[filter_name.to_sym] rescue nil
+      @text   = text
+    end
+
+    def filter
+      process_macros
+      @filter ? @filter.filter(@text) : @text
+    end
+    
+    protected
+      def process_macros
+        #RAILS_DEFAULT_LOGGER.warn "PROCESSING MACROS: #{::FilteredColumn.macros.keys.inspect}"
+        @@patterns.each do |pattern|
+          @text.gsub!(pattern) do |match|
+            #RAILS_DEFAULT_LOGGER.warn "our match: #{$2}"
+            key = "#{$2}_macro".to_sym
+            if !$2.blank? && FilteredColumn.macros.has_key?(key)
+              #RAILS_DEFAULT_LOGGER.warn "It has the key!"
+              macro = FilteredColumn.macros[key]
+              macro_text = macro ? macro.filter(hash_from_attributes($3), $4.to_s) : $4.to_s
+              @filter ? @filter.escape(macro_text) : macro_text
+            end
+          end
+        end
+      end
+
+      def hash_from_attributes(string)
+        attributes = {}
+        string.gsub(/([^ =]+="[^"]*")/) do |match|
+          key, value = match.split(/=/, 2)
+          attributes[key] = value.gsub(/"/, '')
+        end
+        attributes.symbolize_keys!
+      end
+  end
+end

data/vendor/gems/filtered_column/lib/filtered_column/version.rb

@@ -0,0 +1,3 @@
+module FilteredColumn
+  VERSION = "0.0.1"
+end

data/vendor/gems/filtered_column/tasks/filtered_column_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Generate macros"
+# task :filtered_column do
+#   # Task goes here
+# end

data/vendor/gems/filtered_column/test/abstract_unit.rb

@@ -0,0 +1,73 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment'))
+require 'action_controller/vendor/html-scanner/html/document'
+require 'breakpoint'
+
+Test::Unit::TestCase.class_eval do
+  def assert_filters_called_on(*filters)
+    FilteredColumn::Processor.called_filters = []
+    filtered = yield
+    filtered.save if filtered
+    assert_equal filters.length, (FilteredColumn::Processor.called_filters & filters).length, "#{filters.map(&:inspect).join(', ')} expected, #{FilteredColumn::Processor.called_filters.map(&:inspect).join(', ')} called"
+  end
+
+  def assert_no_filters_called_on(klass, &block)
+    assert_filters_called_on &block
+  end
+
+  def process_filter(filter, text)
+    FilteredColumn::Processor.new(filter, text).filter
+  end
+  
+  def process_macros(text)
+    process_filter nil, text
+  end
+end
+
+class SampleMacro < FilteredColumn::Macros::Base
+  def self.filter(attributes, inner_text = '')
+    "foo: #{attributes[:foo] || attributes[:foo_bar]} - flip: #{attributes[:flip]} - text: #{inner_text}"
+  end
+end
+
+FilteredColumn.macros[:sample_macro] = SampleMacro
+
+FilteredColumn::Processor.class_eval do
+  @@called_filters = []
+  cattr_accessor :called_filters
+  def filter_with_audit
+    (called_filters << @filter.filter_key).uniq! if @filter
+    filter_without_audit
+  end
+  alias_method_chain :filter, :audit
+end
+
+class Article < ActiveRecord::Base
+  def self.columns() @columns ||= []; end
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+  end
+
+  column :body,                           :string
+  column :body_html,                      :string
+  column :textile_body,                   :string
+  column :textile_body_html,              :string
+  column :textile_and_markdown_body,      :string
+  column :textile_and_markdown_body_html, :string
+  column :no_textile_body,                :string
+  column :no_textile_body_html,           :string
+  column :filter,                         :string
+  column :sample_macro_body,              :string
+  column :sample_macro_body_html,         :string
+
+  filtered_column :body
+  filtered_column :textile_body,              :only   => :textile_filter
+  filtered_column :textile_and_markdown_body, :only   => [:textile_filter, :markdown_filter]
+  filtered_column :no_textile_body,           :except => :textile_filter
+  
+  def save
+    valid? && send(:callback, :before_save) && true
+  end
+end