publishing_logic 0.2.0 → 0.3.0

data/rails_generators/publishing_logic_fields/USAGE

@@ -1,2 +0,0 @@
-Real usage: ./script/generate publishing_logic_fields model_name [options]
-Note: The generator will fail if the model does not  exist

data/rails_generators/publishing_logic_fields/publishing_logic_fields_generator.rb

@@ -1,34 +0,0 @@
-class PublishingLogicFieldsGenerator < Rails::Generator::NamedBase
-  default_options :use_published_until_field => true, :skip_admin_form => false
-
-  def initialize(args, options)
-    super(args, options)
-  end
-
-  def manifest
-    record do |m|
-      class_name.camelize.constantize # Raise an error if model does not yet exist
-      m.migration_template 'db/migrate/add_publishing_logic_fields.rb.erb', 'db/migrate', :assigns => {
-        :migration_name => "AddPublishingLogicFieldsTo#{class_name.pluralize.gsub(/::/, '')}",
-        :use_published_until_field => options[:use_published_until_field]
-      }, :migration_file_name => "add_publishing_logic_fields_to_#{file_path.gsub(/\//, '_').pluralize}"
-      unless options[:skip_admin_form]
-        m.template 'app/views/publishing_logic_fields.html.erb',
-                   File.join('app', 'views', 'admin', plural_name, "_publishing_logic_fields.html.erb"),
-                   :assigns => {
-                     :use_published_until_field => options[:use_published_until_field]
-                   }
-      end
-    end
-  end
-
-  protected
-    def add_options!(opt)
-      opt.separator ''
-      opt.separator 'Options:'
-      opt.on("--no-published-until",
-             "Don't add the published_until field to this model") { |v| options[:use_published_until_field] = false }
-      opt.on("--skip-admin-form",
-             "Don't generate the admin form partial for this model") { |v| options[:skip_admin_form] = true }
-    end
-end

data/rails_generators/publishing_logic_fields/templates/app/views/publishing_logic_fields.html.erb

@@ -1,12 +0,0 @@
-<p>
-  <%%= form.label :published_at %><br />
-  <%%= form.datetime_select :published_at %>
-</p>
-<% if use_published_until_field %><p>
-  <%%= form.label :published_until %><br />
-  <%%= form.datetime_select :published_until %>
-</p><% end %>
-<p>
-  <%%= form.label :publishing_enabled %>
-  <%%= form.check_box :publishing_enabled %>
-</p>

data/rails_generators/publishing_logic_fields/templates/db/migrate/add_publishing_logic_fields.rb.erb

@@ -1,18 +0,0 @@
-<% table_name = class_name.underscore.camelize.tableize %>
-
-class <%= migration_name %> < ActiveRecord::Migration
-  def self.up
-    change_table :<%= table_name %> do |t|
-      t.boolean :publishing_enabled
-      t.datetime :published_at<% if use_published_until_field %>, :published_until<% end %>
-      t.index [:published_at, :publishing_enabled<% if use_published_until_field %>, :published_until<% end %>], :name => 'index_<%= table_name %>_on_publishing_logic_fields'
-    end
-  end
-
-  def self.down
-    change_table :<%= table_name %> do |t|
-      t.remove :publishing_enabled, :published_at<% if use_published_until_field %>, :published_until<% end %>
-      t.remove_index :name => 'index_<%= table_name %>_on_publishing_logic_fields'
-    end
-  end
-end

data/spec/general_model_logic.rb

@@ -1,93 +0,0 @@
-shared_examples_for 'a model with publish logic' do
-  def create_objects_with_different_published_at_dates(for_class)
-    factory_name = for_class.name.underscore.to_sym
-    @object2 = Factory.create(factory_name, :publishing_enabled => true, :published_at => 2.days.ago)
-    @object1 = Factory.create(factory_name, :publishing_enabled => true, :published_at => 1.days.ago)
-    @object3 = Factory.create(factory_name, :publishing_enabled => true, :published_at => 3.days.ago)
-  end
-
-  describe "ordering by published_at" do
-    describe "from the published scope" do
-      before do
-        create_objects_with_different_published_at_dates(@class)
-      end
-
-      describe "newest first" do
-        it "should be the most recently published object" do
-          @class.published.newest.should == @object1
-        end
-      end
-
-      describe "oldest first" do
-        it "should be the object published the longest ago" do
-          @class.published.oldest.should == @object3
-        end
-      end
-    end
-
-    describe "by publication date oldest first" do
-      before do
-        create_objects_with_different_published_at_dates(@class)
-      end
-
-      it "should return the items, oldest first" do
-        @class.by_publication_date_oldest_first.map(&:id).should == [@object3,
-                                                                     @object2,
-                                                                     @object1].map(&:id)
-      end
-
-      it "should order by created_at date if published_ats are equal" do
-        @object2b = Factory.create(@class.name.underscore.to_sym,
-                                   :publishing_enabled => true,
-                                   :published_at => @object2.published_at,
-                                   :created_at => 3.days.ago)
-        @class.by_publication_date_oldest_first.map(&:id).should == [@object3,
-                                                                     @object2b,
-                                                                     @object2,
-                                                                     @object1].map(&:id)
-      end
-
-      it 'should have deprecated by_date_oldest_first' do
-        assert_deprecated do
-          @class.by_date_oldest_first
-        end
-      end
-    end
-
-    describe "by publication date newest first" do
-      before do
-        create_objects_with_different_published_at_dates(@class)
-      end
-
-      it "should return the items, newest first" do
-        @class.by_publication_date_newest_first.map(&:id).should == [@object1,
-                                                                     @object2,
-                                                                     @object3].map(&:id)
-      end
-
-      it "should order by created_at date if published_ats are equal" do
-        @object2b = Factory.create(@class.name.underscore.to_sym,
-                                   :publishing_enabled => true,
-                                   :published_at => @object2.published_at,
-                                   :created_at => 3.days.from_now)
-        @class.by_publication_date_newest_first.map(&:id).should == [@object1,
-                                                                     @object2b,
-                                                                     @object2,
-                                                                     @object3].map(&:id)
-      end
-
-      it 'should have deprecated by_date_newest_first' do
-        assert_deprecated do
-          @class.by_date_newest_first
-        end
-      end
-    end
-
-    it "should have a newest first ordering that is the reverse of the oldest first ordering for identical objects" do
-      creation_time = 2.days.ago
-      publish_time = 1.days.ago
-      5.times { Factory.create(@class.name.underscore.to_sym, :created_at => creation_time, :published_at => publish_time) }
-      @class.by_publication_date_newest_first.map(&:id).should == @class.by_publication_date_oldest_first.map(&:id).reverse
-    end
-  end
-end

data/spec/models_with_all_fields_spec.rb

@@ -1,85 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-require 'general_model_logic'
-
-describe 'Using publishing logic on models with all fields' do
-  describe "published?" do
-    describe "with publishing enabled" do
-      it "should be published by default" do
-        Factory.create(:programme,
-                       :publishing_enabled => true,
-                       :published_at => nil,
-                       :published_until => nil).should be_published
-      end
-
-      it "should not be published if the published_at datetime is in the future" do
-        Factory.create(:programme,
-                       :publishing_enabled => true,
-                       :published_at => 5.seconds.from_now,
-                       :published_until => nil).should_not be_published
-      end
-
-      it "should not be published if the published_until datetime is in the past" do
-        Factory.create(:programme,
-                       :publishing_enabled => true,
-                       :published_at => nil,
-                       :published_until => 5.seconds.ago).should_not be_published
-      end
-    end
-    describe "with publishing disabled" do
-      it "should not be published" do
-        Factory.create(:programme,
-                       :publishing_enabled => false,
-                       :published_at => 1.days.ago,
-                       :published_until => 10.days.from_now).should_not be_published
-      end
-    end
-  end
-
-  describe "published named scope" do
-    it "should include published objects" do
-      programme = Factory.create(:programme, :publishing_enabled => true)
-      Programme.published.should == [programme]
-    end
-
-    it "should not include any unpublished objects" do
-      Factory.create(:programme, :publishing_enabled => false)
-      Programme.published.should be_empty
-    end
-
-    it "should not include objects with a published_until in the past" do
-      Factory.create(:programme,
-                     :publishing_enabled => true,
-                     :published_until => 5.seconds.ago)
-      Programme.published.should be_empty
-    end
-
-    it "should not include objects with a published_at in the future" do
-      Factory.create(:programme,
-                     :publishing_enabled => true,
-                     :published_at => 5.seconds.from_now)
-      Programme.published.should be_empty
-    end
-
-    it "should get a new Time.now for each invocation of the named scope" do
-      mock_now = mock('now', :utc => 20.days.from_now, :to_f => 0)
-      Time.stub(:now).and_return mock_now
-      Programme.published
-    end
-
-    it "should use the utc of the current time" do
-      # Make sure utc is used, which is hard to test as a behaviour
-      mock_now = mock('now')
-      Time.stub(:now).and_return mock_now
-      mock_now.should_receive(:utc).twice
-      Programme.published
-    end
-  end
-
-  describe 'generally' do
-    before do
-      @class = Programme
-    end
-
-    it_should_behave_like 'a model with publish logic'
-  end
-end

data/spec/models_with_no_published_until_field_spec.rb

@@ -1,68 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-require 'general_model_logic'
-
-describe 'Using publishing logic on models with no published until field' do
-  describe "published?" do
-    describe "with publishing enabled" do
-      it "should be published by default" do
-        Factory.create(:article,
-                       :publishing_enabled => true,
-                       :published_at => nil).should be_published
-      end
-
-      it "should not be published if the published_at datetime is in the future" do
-        Factory.create(:article,
-                       :publishing_enabled => true,
-                       :published_at => 5.seconds.from_now).should_not be_published
-      end
-    end
-    describe "with publishing disabled" do
-      it "should not be published" do
-        Factory.create(:article,
-                       :publishing_enabled => false,
-                       :published_at => 1.days.ago).should_not be_published
-      end
-    end
-  end
-
-  describe "published named scope" do
-    it "should include published objects" do
-      article = Factory.create(:article, :publishing_enabled => true)
-      Article.published.should == [article]
-    end
-
-    it "should not include any unpublished objects" do
-      Factory.create(:article, :publishing_enabled => false)
-      Article.published.should be_empty
-    end
-
-    it "should not include objects with a published_at in the future" do
-      Factory.create(:article,
-                     :publishing_enabled => true,
-                     :published_at => 5.seconds.from_now)
-      Article.published.should be_empty
-    end
-
-    it "should get a new Time.now for each invocation of the named scope" do
-      mock_now = mock('now', :utc => 20.days.from_now, :to_f => 0)
-      Time.stub(:now).and_return mock_now
-      Article.published
-    end
-
-    it "should use the utc of the current time" do
-      # Make sure utc is used, which is hard to test as a behaviour
-      mock_now = mock('now')
-      Time.stub(:now).and_return mock_now
-      mock_now.should_receive(:utc).once
-      Article.published
-    end
-  end
-
-  describe 'generally' do
-    before do
-      @class = Article
-    end
-
-    it_should_behave_like 'a model with publish logic'
-  end
-end

data/spec/spec.opts

@@ -1 +0,0 @@
---color

data/spec/spec_helper.rb

@@ -1,55 +0,0 @@
-require 'rubygems'
-gem 'rspec'
-gem 'rspec-rails'
-gem 'factory_girl'
-gem 'activesupport'
-gem 'activerecord'
-gem 'database_cleaner'
-
-require 'factory_girl'
-require 'active_support'
-require 'active_record'
-
-# We don't need all of spec/rails - just the bits that're to do with ActiveRecord
-
-require 'active_support/test_case'
-require 'active_record/fixtures' if defined?(ActiveRecord::Base)
-
-require 'spec/test/unit'
-
-require "spec/rails/example/model_example_group"
-require 'spec/rails/extensions/spec/matchers/have'
-
-require 'spec/rails/matchers/ar_be_valid'
-require 'spec/rails/matchers/change'
-
-require 'spec/rails/mocks'
-
-require 'spec/rails/extensions/active_support/test_case'
-require 'spec/rails/extensions/active_record/base'
-
-require 'spec/rails/interop/testcase'
-
-Spec::Example::ExampleGroupFactory.default(ActiveSupport::TestCase)
-
-require 'publishing_logic'
-
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("test.log")
-
-# Time zone setup Publishing Logic assumes that you've properly set up your timezones.
-Time.zone_default = Time.send(:get_zone, 'UTC')
-ActiveRecord::Base.time_zone_aware_attributes = true
-ActiveRecord::Base.default_timezone = :utc
-
-Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
-
-# require 'publishing_logic'
-# require 'spec'
-# require 'spec/autorun'
-
-require 'database_cleaner'
-DatabaseCleaner.strategy = :truncation
-
-Spec::Runner.configure do |config|
-end

data/spec/support/database_cleanliness.rb

@@ -1,14 +0,0 @@
-Spec::Runner.configure do |config|
-  config.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
-  config.before(:each) do
-    DatabaseCleaner.start
-  end
-
-  config.after(:each) do
-    DatabaseCleaner.clean
-  end
-end

data/spec/support/database_connection.rb

@@ -1,4 +0,0 @@
-ActiveRecord::Base.establish_connection(
-  :adapter => "sqlite3",
-  :database => "#{File.join(File.dirname(__FILE__),'test_publishing_logic.db')}"
-)

data/spec/support/database_migrations.rb

@@ -1,56 +0,0 @@
-module PublishingLogic
-  module Migrations
-    class AddProgrammes < ActiveRecord::Migration
-      def self.up
-        create_table :programmes do |t|
-          t.boolean :publishing_enabled
-          t.datetime :published_at
-          t.datetime :published_until
-          t.timestamps
-        end
-
-        add_index :programmes, [:published_at, :publishing_enabled, :published_until], :name => 'index_programmes_on_publishing_logic_fields'
-      end
-
-      def self.down
-        remove_index :programmes, :name => 'index_programmes_on_publishing_logic_fields'
-      end
-    end
-
-    class AddArticles < ActiveRecord::Migration
-      def self.up
-        create_table :articles do |t|
-          t.boolean :publishing_enabled
-          t.datetime :published_at
-          t.timestamps
-        end
-
-        add_index :programmes, [:published_at, :publishing_enabled], :name => 'index_articles_on_publishing_logic_fields'
-      end
-
-      def self.down
-        remove_index :articles, :name => 'index_articles_on_publishing_logic_fields'
-      end
-    end
-  end
-end
-
-if ActiveRecord::Migrator.current_version != 2
-  migrator = ActiveRecord::Migrator.new(:up, '', 2)
-  migrator.instance_eval {
-    migration_1 = ActiveRecord::MigrationProxy.new
-    migration_1.instance_eval {
-      @name = 'add_programmes'
-      @version = 1
-      @migration = PublishingLogic::Migrations::AddProgrammes
-    }
-    migration_2 = ActiveRecord::MigrationProxy.new
-    migration_2.instance_eval {
-      @name = 'add_articles'
-      @version = 2
-      @migration = PublishingLogic::Migrations::AddArticles
-    }
-    @migrations = [ migration_1, migration_2 ]
-  }
-  migrator.migrate
-end