adva_cms 0.0.1

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

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), 'abstract_unit')
+
+class FilteredColumnTest < Test::Unit::TestCase
+  {
+    :textile  => { :input  => '*foo*',        :output => '<p><strong>foo</strong></p>' },
+    :markdown => { :input  => "# bar\n\nfoo", :output => "<h1>bar</h1>\n\n<p>foo</p>" },
+    :smartypants => { :input => "\"abc\" `<def ghi=\"jkl\">`\n\n    <mno pqr=\"stu\">...</mno>",
+      :output => "<p>&#8220;abc&#8221; <code>&lt;def ghi=\"jkl\"&gt;</code></p>\n\n<pre><code>&lt;mno pqr=\"stu\"&gt;...&lt;/mno&gt;\n</code></pre>" },
+  }.each do |filter_name, values|
+    define_method "test_should_filter_with_#{filter_name}" do
+      assert_equal values[:output], FilteredColumn::Processor.new("#{filter_name}_filter", values[:input]).filter
+    end
+
+    define_method "test_should_filter_model_attribute_with_#{filter_name}" do
+      assert_filters_called_on "#{filter_name}_filter".to_sym do
+        a = Article.create :body => values[:input], :filter => "#{filter_name}_filter"
+        assert_equal values[:output], a.body_html
+      end
+    end
+  end
+  
+  def test_should_retrieve_filter
+    assert_equal FilteredColumn::Filters::TextileFilter, FilteredColumn.filters[:textile_filter]
+  end
+
+  def test_should_use_default_filter_names
+    assert_equal 'Textile',  FilteredColumn::Filters::TextileFilter.filter_name
+    assert_equal 'Markdown', FilteredColumn::Filters::MarkdownFilter.filter_name
+  end
+
+  def test_should_allow_filter_name_customization
+    assert_equal 'Markdown with Smarty Pants', FilteredColumn::Filters::SmartypantsFilter.filter_name
+  end
+ 
+  def test_should_use_default_filter_keys
+    assert_equal :textile_filter,     FilteredColumn::Filters::TextileFilter.filter_key
+    assert_equal :markdown_filter,    FilteredColumn::Filters::MarkdownFilter.filter_key
+    assert_equal :smartypants_filter, FilteredColumn::Filters::SmartypantsFilter.filter_key
+  end
+
+  def test_should_call_no_filters_with_no_data
+    assert_no_filters_called_on(Article) { Article.new }
+  end
+  
+  def test_should_escape_textile_filter
+    assert_equal '<notextile>foo</notextile>', FilteredColumn::Filters::TextileFilter.escape('foo')
+  end
+  
+  def test_should_parse_content_with_html_tokenizer
+    article = Article.create :body => '*foo*', :filter => "textile_filter"
+    assert_kind_of HTML::Document, article.body_doc
+  end
+end

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

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'abstract_unit')
+
+class MacroFilterTest < Test::Unit::TestCase
+  def test_should_retrieve_macro
+    assert_equal SampleMacro, FilteredColumn.macros[:sample_macro]
+  end
+  
+  def test_sample_macro
+    assert_equal %(foo:  - flip:  - text: test), process_macros("<macro:sample>test</macro:sample>")
+  end
+
+  def test_sample_macro_with_attributes
+    assert_equal %(foo: foo - flip: bar - text: test), process_macros(%(<macro:sample foo="foo" flip="bar">test</macro:sample>))
+  end
+
+  def test_sample_macro_with_underscored_attributes
+    assert_equal %(foo: foo - flip: bar - text: test), process_macros(%(<macro:sample foo_bar="foo" flip="bar">test</macro:sample>))
+  end
+  
+  def test_should_escape_macros_with_textile
+    assert_equal %(foo:  - flip:  - text: <tt>test</tt>), process_filter(:textile_filter, "<macro:sample><tt>test</tt></macro:sample>")
+  end
+end

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

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

data/vendor/gems/has_counter/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/has_counter/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sven Fuchs
+
+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/has_counter/README.markdown

@@ -0,0 +1,64 @@
+## Has Counter
+
+Allows to cache the number of records for a `has_many` association.
+
+Yes, this is the same thing you can do by setting the `:counter_cache` option
+on the corresponding `belongs_to` association.
+
+The reason for reinventing the `counter_cache` wheel here is that
+`counter_cache` is a bit inflexible. We need to "hardcode" the counter_cache
+column and thereby clutter the schema. This can especially get annoying in
+combo with STI, when - e.g. one subclass needs some `counter_caches` that are
+specific to this subclass only.
+
+Instead, with `has_counter`, counters can be separated into an external table 
+with generic column names. 
+
+The ActiveRecord `counter_cache` mechanism also requires to put the
+`:counter_cache` directive on the `belongs_to` association of the counted class,
+which adds some tight coupleing that we might want to avoid.
+
+Instead, with `has_counter`, we can observe the counted class and update our
+counters "from the outside", so the counted class does not need to know about
+the fact that somebody else keeps a counter on it.
+
+## Usage
+
+    class User
+      has_counter :posts
+    end
+    
+This will add a `has_one :post_counter` association to the User model as well
+as the appropriate callbacks for creating the initial counter object when a
+User is created and in/decrementing the counter when a Post is created or
+destroyed. 
+
+For convenience it also adds a `posts_count` method to the User model that you
+should use to read the actual numeric count value. 
+
+In case you need that you can use the following methods to manually
+in/decrement or set the counter value:
+
+    user.posts_counter.increment! # increments and saves the counter
+    user.posts_counter.decrement! # decrement and saves the counter
+    user.posts_counter.set(5)     # sets the counter to 5 and saves it
+    
+## Limitations
+
+There are quite some. The above example expects that there is the following
+association on the Posts model:  
+
+    class Post
+      belongs_to :user
+    end  
+    
+`User.has_counter :posts` also expects that a Post model exists and that this
+is the one you want to count. At this point you can **not** count arbitrary
+associations like:
+
+    class Post
+      has_counter :approved_comments # with special conditions/callbacks
+    end
+
+
+    

data/vendor/gems/has_counter/README.md

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

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

data/vendor/gems/has_counter/db/migrate/20080601194338_create_counters_table.rb.rb

@@ -0,0 +1,13 @@
+class CreateCountersTable < ActiveRecord::Migration
+  def self.up
+    create_table :counters, :force => true do |t|
+      t.references :owner, :polymorphic => true
+      t.string     :name, :limit => 25
+      t.integer    :count, :default => 0
+    end    
+  end
+
+  def self.down
+    drop_table :counters
+  end
+end

data/vendor/gems/has_counter/has_counter.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/has_counter/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          = "has_counter"
+  gem.require_paths = ["lib"]
+  gem.version       = HasCounter::VERSION
+end

data/vendor/gems/has_counter/lib/active_record/has_counter.rb

@@ -0,0 +1,64 @@
+module ActiveRecord
+  module HasCounter
+    class << self
+      def included(base)
+        base.extend ActMacro
+      end
+    end
+
+    module ActMacro
+      def has_counter(*names)
+        options = names.extract_options!
+        callbacks = options[:callbacks] || { :after_create  => :increment!, :after_destroy => :decrement! }
+
+        class_attribute :"update_counters"
+        self.update_counters ||= {}
+
+        names.each do |name|
+          counter_name = :"#{name}_counter"
+          owner_name = options[:as] || self.name.demodulize.underscore
+          class_name = options[:class_name] || name
+
+          define_method :"#{name}_count" do
+            send(counter_name).count
+          end
+
+          has_one counter_name, -> { where(name: name) },
+                                as: :owner,
+                                class_name: "Counter",
+                                dependent: :delete
+
+          # create the counter lazily upon first access
+          class_eval <<-code, __FILE__, __LINE__
+            def #{counter_name}_with_lazy_creation(force_reload = false)
+              result = #{counter_name}_without_lazy_creation(force_reload)
+              if result.nil?
+                Counter.create!(:owner => self, :name => #{name.to_s.inspect})
+                result = #{counter_name}_without_lazy_creation(true)
+              end
+              result
+            end
+            alias_method_chain counter_name, :lazy_creation
+          code
+
+          # Wire up the counted class so that it updates our counter, basically
+          # an anonymous callback/observer pattern
+          target = class_name.to_s.classify.constantize
+          callbacks.keys.each do |callback|
+            target.send callback do |record|
+              owner = record.send(owner_name) if record.respond_to?(owner_name)
+              # do not update the counter when counter's owner (e.g. article) is not frozen (deleted)
+              if self === owner && !owner.frozen? && record.class == target
+                method = callbacks[callback]
+                method = method.call(record) if Proc === method
+                counter = owner.send(counter_name) if method
+                counter.send method if counter && method
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/vendor/gems/has_counter/lib/counter.rb

@@ -0,0 +1,23 @@
+class Counter < ActiveRecord::Base
+  belongs_to :owner, :polymorphic => true
+  
+  def increment!
+    set count + 1
+  end
+  
+  def increment_by!(value)
+    set count + value
+  end
+  
+  def decrement!
+    set count - 1
+  end
+  
+  def decrement_by!(value)
+    set count - value
+  end
+  
+  def set(value)
+    update_attributes! :count => value
+  end
+end

data/vendor/gems/has_counter/lib/has_counter.rb

@@ -0,0 +1,4 @@
+require "has_counter/version"
+require "counter"
+require "active_record/has_counter"
+ActiveRecord::Base.send :include, ActiveRecord::HasCounter

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

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

data/vendor/gems/has_counter/spec/has_counter_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper.rb")
+
+describe "has_counter:", "using default after_create and after_destroy callbacks" do
+  before :each do
+    Counter.delete_all
+    CounterSpec::Content.delete_all
+    CounterSpec::Comment.delete_all
+
+    @content = CounterSpec::Content.create! :title => 'first content'
+  end
+  
+  it "instantiates a counter" do
+    @content.comments.create! :text => 'first comment'
+    @content.comments_counter.should_not be_nil
+  end
+  
+  it "increments the counter on creation" do
+    @content.comments.create! :text => 'first comment'
+    @content.comments_count.should == 1
+  end
+  
+  it "decrements the counter on deletion" do
+    @comment = @content.comments.create! :text => 'first comment'
+    @comment.destroy
+    @content.comments_count.should == 0
+  end
+end
+
+describe "has_counter:", "using a method name as after_create and after_destroy callbacks" do
+  before :each do
+    Counter.delete_all
+    CounterSpec::Content.delete_all
+    CounterSpec::Comment.delete_all
+
+    @content = CounterSpec::Content.create! :title => 'first content'
+  end
+  
+  it "instantiates a counter" do
+    @content.comments.create! :text => 'first comment'
+    @content.approved_comments_counter.should_not be_nil
+  end
+  
+  it "increments the counter on creation" do
+    @content.comments.create! :text => 'first comment', :approved => 1
+    @content.approved_comments_count.should == 1
+  end
+  
+  it "decrements the counter on deletion" do
+    @comment = @content.comments.create! :text => 'first comment', :approved => 1
+    @content.approved_comments_count.should == 1
+    @comment.destroy
+    @content.reload
+    @content.approved_comments_count.should == 0
+  end
+end

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

@@ -0,0 +1,117 @@
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib/'
+
+ENV["RAILS_ENV"] = "test"
+
+require 'rubygems'
+require 'active_record'
+
+ActiveRecord::Base.class_eval do 
+  class << self
+    # no peeping toms (aka observers) wanted here
+    alias_method :dont_instantiate_observers, :instantiate_observers
+    def instantiate_observers; end
+  end
+end
+
+require File.expand_path(File.dirname(__FILE__) + "/../../../../config/environment")
+require 'spec'
+require 'spec/rails'
+
+config = {'adapter' => 'sqlite3', 'dbfile' => File.dirname(__FILE__) + '/has_counter.sqlite3.db'}
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/has_counter.spec.log')
+ActiveRecord::Base.establish_connection(config)
+
+require 'counter'
+unless Counter.table_exists?
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :counters, :force => true do |t|
+      t.references :owner, :polymorphic => true
+      t.string     :name, :limit => 25
+      t.integer    :count, :default => 0
+    end
+  end
+end
+
+module CounterSpec
+  class Comment < ActiveRecord::Base
+    self.table_name = 'comments'
+    
+    belongs_to :content
+    after_save    :update_commentable
+    after_destroy :update_commentable
+    
+    unless table_exists?
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :comments, :force => true do |t|
+          t.references :content
+          t.text :text
+          t.integer :approved
+        end
+      end
+    end
+
+    def unapproved?
+      !approved?
+    end
+  
+    def just_approved?
+      approved? && approved_changed?
+    end
+  
+    def just_unapproved?
+      !approved? && approved_changed? 
+    end
+  
+    def update_commentable
+      content.after_comment_update(self)
+    end 
+  end
+
+  class Content < ActiveRecord::Base
+    self.table_name = 'contents'
+    
+    has_many :comments
+    
+    has_counter :comments, 
+                :class_name => 'CounterSpec::Comment'
+                
+    has_counter :approved_comments, 
+                :class_name => 'CounterSpec::Comment', 
+                :after_create => false,
+                :after_destroy => false
+                # :after_destroy => lambda{|record| 
+                #   :decrement! if record.approved? 
+                # },
+                # :after_save => lambda{|record| 
+                #   record.just_approved? && :increment! or
+                #   record.just_unapproved? && :decrement!
+                # }
+                
+    def after_comment_update(comment)
+      method = if comment.frozen? && comment.approved?
+        :decrement!
+      elsif comment.just_approved? 
+        :increment!
+      elsif comment.just_unapproved? 
+        :decrement!
+      end
+      approved_comments_counter.send method if method
+    end
+
+    unless table_exists?
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :contents, :force => true do |t|
+          t.string :title, :limit => 50
+        end
+      end
+    end
+  end
+end
+
+
+
+
+