landable 1.7.0

data/lib/landable/traffic/user_tracker.rb

@@ -0,0 +1,65 @@
+module Landable
+  module Traffic
+    class UserTracker < Tracker
+      def track
+        load
+        cookie
+        record_visit
+      end
+
+      def load
+        hash = session[:landable] || {}
+
+        @cookie_id        = cookies[:landable]
+
+        @visit_id         = hash[KEYS[:visit_id]]
+        @last_visit_time  = hash[KEYS[:visit_time]]
+        @visitor_id       = hash[KEYS[:visitor_id]]
+        @visitor_hash     = hash[KEYS[:visitor_hash]]
+        @attribution_hash = hash[KEYS[:attribution_hash]]
+        @referer_hash     = hash[KEYS[:referer_hash]]
+      end
+
+      def record_page_view
+        PageView.create do |p|
+          p.http_method  = request.method
+          p.mime_type    = request.format.to_s
+          p.path         = request.path
+          p.query_string = untracked_parameters.to_query
+          p.request_id   = request.uuid
+
+          p.click_id     = tracking_parameters["click_id"]
+
+          p.http_status  = response.status
+
+          p.visit_id     = @visit_id
+
+          p.response_time = ( Time.now - @start_time ) * 1000
+        end
+      end
+
+      def save
+        record_page_view
+
+        session[:landable] = {
+          KEYS[:visit_id]         => @visit_id,
+          KEYS[:visit_time]       => Time.current,
+          KEYS[:visitor_id]       => @visitor_id,
+          KEYS[:visitor_hash]     => visitor_hash,
+          KEYS[:attribution_hash] => attribution? ? attribution_hash : @attribution_hash,
+          KEYS[:referer_hash]     => referer_changed? ? referer_hash : @referer_hash
+        }
+      end
+
+      def identify(identifier)
+        visit = Visit.find(@visit_id)
+        owner = Owner.where(owner: identifier).first_or_create
+
+        visit.owner = owner
+        visit.save!
+
+        Ownership.where(cookie_id: @cookie_id, owner: owner).first_or_create
+      end
+    end
+  end
+end

data/lib/landable/version.rb

@@ -0,0 +1,10 @@
+module Landable
+  module VERSION
+    MAJOR = 1
+    MINOR = 7
+    PATCH = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+  end
+end

data/lib/tasks/landable/cucumber.rake

@@ -0,0 +1,67 @@
+namespace :landable do
+  # IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+  # It is recommended to regenerate this file in the future when you upgrade to a 
+  # newer version of cucumber-rails. Consider adding your own code to a new file 
+  # instead of editing this one. Cucumber will automatically load all features/**/*.rb
+  # files.
+
+
+  unless ARGV.any? {|a| a =~ /^gems/} # Don't load anything when running the gems:* tasks
+
+  vendored_cucumber_bin = Dir["#{Rails.root}/vendor/{gems,plugins}/cucumber*/bin/cucumber"].first
+  $LOAD_PATH.unshift(File.dirname(vendored_cucumber_bin) + '/../lib') unless vendored_cucumber_bin.nil?
+
+  begin
+    require 'cucumber/rake/task'
+
+    namespace :cucumber do
+      Cucumber::Rake::Task.new({:ok => 'db:test:prepare'}, 'Run features that should pass') do |t|
+        t.binary = vendored_cucumber_bin # If nil, the gem's binary is used.
+        t.fork = true # You may get faster startup if you set this to false
+        t.profile = 'default'
+      end
+
+      Cucumber::Rake::Task.new({:wip => 'db:test:prepare'}, 'Run features that are being worked on') do |t|
+        t.binary = vendored_cucumber_bin
+        t.fork = true # You may get faster startup if you set this to false
+        t.profile = 'wip'
+      end
+
+      Cucumber::Rake::Task.new({:rerun => 'db:test:prepare'}, 'Record failing features and run only them if any exist') do |t|
+        t.binary = vendored_cucumber_bin
+        t.fork = true # You may get faster startup if you set this to false
+        t.profile = 'rerun'
+      end
+
+      desc 'Run all features'
+      task :all => [:ok, :wip]
+
+      task :statsetup do
+        require 'rails/code_statistics'
+        ::STATS_DIRECTORIES << %w(Cucumber\ features features) if File.exist?('features')
+        ::CodeStatistics::TEST_TYPES << "Cucumber features" if File.exist?('features')
+      end
+    end
+    desc 'Alias for cucumber:ok'
+    task :cucumber => 'cucumber:ok'
+
+    task :default => :cucumber
+
+    task :features => :cucumber do
+      STDERR.puts "*** The 'features' task is deprecated. See rake -T cucumber ***"
+    end
+
+    # In case we don't have ActiveRecord, append a no-op task that we can depend upon.
+    task 'db:test:prepare' do
+    end
+
+    task :stats => 'cucumber:statsetup'
+  rescue LoadError
+    desc 'cucumber rake task not available (cucumber not installed)'
+    task :cucumber do
+      abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+    end
+  end
+
+  end
+end

data/lib/tasks/landable/data.rake

@@ -0,0 +1,166 @@
+namespace :landable do
+  namespace :data do
+    desc "Clean & restore database from specified source"
+    task :restore => [ 'db:drop', 'db:create', 'db:migrate', 'dump_and_load' ]
+
+    desc 'Restore database from specified source'
+    task dump_and_load: :environment do
+       STDOUT.puts 'Enter Remote DB Host'
+       host = STDIN.gets.strip
+
+       STDOUT.puts 'Enter Remote Database'
+       database = STDIN.gets.strip
+
+       STDOUT.puts 'Enter Remote Username'
+       username = STDIN.gets.strip
+
+       `pg_dump -h #{host} -U #{username} --data-only --format plain --schema landable #{database} > landable_import.sql`
+       `psql #{Rails.configuration.database_configuration[Rails.env]["database"]} -f landable_import.sql`
+       `rm landable_import.sql`
+    end
+
+    desc "Migrates all to new schema"
+    task :move_schemas, :old_landable, :new_landable, :old_traffic, :new_traffic do |t, args|
+      @old_landable = "#{args[:old_landable]}"
+      @new_landable = "#{args[:new_landable]}"
+      @old_traffic = "#{args[:old_traffic]}"
+      @new_traffic = "#{args[:new_traffic]}"
+
+      Rake.application.invoke_task("landable:data:create_schemas")
+      Rake.application.invoke_task("landable:data:move_tables")
+      Rake.application.invoke_task("landable:data:move_sequences")
+      Rake.application.invoke_task("landable:data:move_triggers")
+    end
+
+    desc "Creates the new schemas"
+    task create_schemas: :environment do
+      create_schema("#{@new_landable}")
+      create_schema("#{@new_traffic}")
+    end
+
+    desc "Move tables to new db schema"
+    task move_tables: :environment do
+      move_objects("#{@old_landable}", "#{@new_landable}", 'r', 'TABLE')
+      move_objects("#{@old_traffic}", "#{@new_traffic}", 'r', 'TABLE')
+    end
+
+    desc "Move sequences to new db schema"
+    task move_sequences: :environment do
+      move_objects("#{@old_landable}", "#{@new_landable}", 'S', 'SEQUENCE')
+      move_objects("#{@old_traffic}", "#{@new_traffic}", 'S', 'SEQUENCE')
+    end
+
+    desc "Move triggers to new db schema"
+    task move_triggers: :environment do
+      create_new_triggers("#{@new_landable}")
+      drop_old_triggers("#{@old_landable}", "#{@new_landable}")
+    end
+
+  end
+
+  def create_schema(schema)
+    connection = ActiveRecord::Base.connection
+
+    sql = %{
+      CREATE SCHEMA #{schema};
+    }
+    puts "Creating #{schema} schema"
+    connection.execute sql
+  end
+
+  def move_objects(from_schema, to_schema, relkind, object_type)
+    connection = ActiveRecord::Base.connection
+
+    # move objects from public to new schema
+    objects = connection.select_all("
+      SELECT o.relname
+        FROM pg_class o
+        JOIN pg_namespace n
+        ON n.oid=o.relnamespace
+        AND n.nspname = '#{from_schema}'
+        AND o.relkind = '#{relkind}'
+        ORDER BY o.relname
+    ")
+
+    objects.each do |object|
+      sql = %{
+        ALTER #{object_type} #{from_schema}.#{object['relname']}
+          SET SCHEMA #{to_schema}
+      }
+      puts "Moving #{from_schema}.#{object['relname']} TO #{to_schema}"
+      connection.execute sql
+    end
+  end
+
+  def create_new_triggers(new_schema)
+    puts "#{new_schema}"
+    connection = ActiveRecord::Base.connection
+    sql = %{
+      CREATE FUNCTION #{new_schema}.pages_revision_ordinal()
+        RETURNS TRIGGER
+        AS
+        $TRIGGER$
+          BEGIN
+
+          IF NEW.ordinal IS NOT NULL THEN
+            RAISE EXCEPTION $$Must not supply ordinal value manually.$$;
+          END IF;
+
+          NEW.ordinal = (SELECT COALESCE(MAX(ordinal)+1,1)
+                          FROM #{new_schema}.page_revisions
+                          WHERE page_id = NEW.page_id);
+
+          RETURN NEW;
+
+          END
+         $TRIGGER$
+         LANGUAGE plpgsql;
+
+      CREATE TRIGGER #{new_schema}_page_revisions__bfr_insert
+        BEFORE INSERT ON #{new_schema}.page_revisions
+        FOR EACH ROW EXECUTE PROCEDURE #{new_schema}.pages_revision_ordinal();
+
+      CREATE FUNCTION #{new_schema}.tg_disallow()
+        RETURNS TRIGGER
+        AS
+        $TRIGGER$
+          BEGIN
+
+          IF TG_LEVEL <> 'STATEMENT' THEN
+            RAISE EXCEPTION $$You should use a statement-level trigger (trigger %, table %)$$, TG_NAME, TG_RELID::regclass;
+          END IF;
+
+          RAISE EXCEPTION $$%s are not allowed on table %$$, TG_OP, TG_RELNAME;
+
+          RETURN NULL;
+
+          END
+         $TRIGGER$
+         LANGUAGE plpgsql;
+
+      CREATE TRIGGER #{new_schema}_page_revisions__no_delete
+        BEFORE DELETE ON #{new_schema}.page_revisions
+        FOR EACH STATEMENT EXECUTE PROCEDURE #{new_schema}.tg_disallow();
+
+      CREATE TRIGGER #{new_schema}_page_revisions__no_update
+        BEFORE UPDATE OF notes, is_minor, page_id, author_id, created_at, ordinal ON #{new_schema}.page_revisions
+        FOR EACH STATEMENT EXECUTE PROCEDURE #{new_schema}.tg_disallow();
+    }
+    puts "Creating new triggers..."
+    connection.execute sql
+  end
+
+  def drop_old_triggers(old_schema, new_schema)
+    connection = ActiveRecord::Base.connection
+    sql = %{
+      DROP TRIGGER IF EXISTS #{old_schema}_page_revisions__bfr_insert ON #{new_schema}.page_revisions;
+      DROP TRIGGER IF EXISTS #{old_schema}_page_revisions__no_delete  ON #{new_schema}.page_revisions;
+      DROP TRIGGER IF EXISTS #{old_schema}_page_revisions__no_update  ON #{new_schema}.page_revisions;
+
+      DROP FUNCTION IF EXISTS #{old_schema}.pages_revision_ordinal();
+      DROP FUNCTION IF EXISTS #{old_schema}.tg_disallow();
+    }
+    puts "Dropping old triggers..."
+    connection.execute sql
+  end
+end

data/lib/tasks/landable/pgtap.rake

@@ -0,0 +1,26 @@
+namespace :landable do
+  namespace :pgtap do
+    def has_pgprove?
+      @@has_prove ||= Kernel.system('which pg_prove > /dev/null')
+    end
+
+    desc "Run PGTap unit tests"
+    task :run, [:test_file] => [ :environment ] do |t, args|
+      dbdir = "#{Rails.root}/../../db"
+
+      tests = args[:test_file] ? args[:test_file] : "*.sql"
+
+      if not has_pgprove?
+        puts "\nPGTap not installed.  Skipping DB unit tests"
+        puts "Reference 'http://pgtap.org/documentation.html#installation' for installation instructions."
+      else
+        # Load pgtap functions into database.  Will not complain if already loaded.
+        ActiveRecord::Base.connection.execute(IO.read("#{dbdir}/pgtap/pgtap.sql"))
+
+        sh "cd #{dbdir}/test && pg_prove -d #{ActiveRecord::Base.connection.current_database} #{tests}"
+      end
+    end
+  end
+
+  task :pgtap => 'pgtap:run'
+end

data/lib/tasks/landable/rdoc.rake

@@ -0,0 +1,11 @@
+require 'rdoc/task'
+
+namespace :landable do
+  RDoc::Task.new(:rdoc) do |rdoc|
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title    = 'Landable'
+    rdoc.options << '--line-numbers'
+    rdoc.rdoc_files.include('README.rdoc')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+end

data/lib/tasks/landable/seed.rake

@@ -0,0 +1,16 @@
+namespace :landable do
+  namespace :seed do
+    desc 'Seed extra data (starter themes)'
+    task :extras => :environment do
+      Landable::Seeds.seed(:extras)
+    end
+
+    desc 'Seed required data (categories)'
+    task :required => :environment do
+      Landable::Seeds.seed(:required)
+    end
+  end
+
+  desc 'Seed required and extra data'
+  task :seed => ['seed:required', 'seed:extras']
+end

data/lib/tasks/landable/spec.rake

@@ -0,0 +1,15 @@
+namespace :landable do
+  begin
+    require 'rspec/core'
+    require 'rspec/core/rake_task'
+
+    desc 'Run specs'
+    RSpec::Core::RakeTask.new(:spec)
+
+  rescue LoadError
+    desc 'Run specs (missing rspec)'
+    task :spec do
+      raise 'rspec not present'
+    end
+  end
+end

data/script/cucumber

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+vendored_cucumber_bin = Dir["#{File.dirname(__FILE__)}/../vendor/{gems,plugins}/cucumber*/bin/cucumber"].first
+if vendored_cucumber_bin
+  load File.expand_path(vendored_cucumber_bin)
+else
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'cucumber'
+  load Cucumber::BINARY
+end

data/spec/concerns/landable/has_assets_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Landable
+  describe HasAssets do
+
+    before(:each) { create_list :asset, 4 }
+
+    let(:assets) { Landable::Asset.first(3) }
+    let(:subject) {
+      build :page, {
+        body: "
+          <div>{% img_tag #{assets[0].name} %}</div>
+          <div>{% asset_url #{assets[1].name} %}</div>
+          <div>{% asset_description #{assets[2].name} %}</div>
+          <div>{% img_tag #{assets[0].name} %}</div>
+        "
+      }
+    }
+
+    describe '#assets' do
+      it 'should return assets matching #asset_names' do
+        result = double()
+        subject.should_receive(:asset_names) { ['one', 'two', 'three'] }
+        Landable::Asset.should_receive(:where).with(name: ['one', 'two', 'three']) { result }
+        subject.assets.should == result
+      end
+    end
+
+    describe '#asset_names' do
+      it 'should pull asset names out of the body' do
+        subject.asset_names.sort.should == assets.map(&:name).uniq.sort
+      end
+    end
+
+    describe '#save_assets!' do
+      it 'should save the assets' do
+        assets_double = double()
+        subject.should_receive(:assets) { assets_double }
+        subject.should_receive(:assets=).with(assets_double)
+        subject.save_assets!
+      end
+
+      it 'should be called during save' do
+        subject.should_receive :save_assets!
+        subject.save!
+      end
+    end
+
+    describe '#assets_as_hash' do
+      it 'should return a hash of asset names to asset instances' do
+        subject.save!
+        subject.assets_as_hash.should == Hash[assets.map { |asset| [asset.name, asset] }]
+      end
+    end
+
+    describe 'body=' do
+      it 'should reset the asset_names cache, then set the body' do
+        subject.instance_eval { @asset_names = 'foo' }
+        subject.body = 'bar'
+        subject.body.should == 'bar'
+        subject.instance_eval { @asset_names }.should be_nil
+        subject.asset_names.should == []
+      end
+    end
+
+    describe '#assets_join_table_name' do
+      it 'should generate the correct join_table, and then apologize for doing so' do
+        Page.send(:assets_join_table_name).should == "#{Landable.configuration.database_schema_prefix}landable.page_assets"
+        PageRevision.send(:assets_join_table_name).should == "#{Landable.configuration.database_schema_prefix}landable.page_revision_assets"
+        Theme.send(:assets_join_table_name).should == "#{Landable.configuration.database_schema_prefix}landable.theme_assets"
+      end
+    end
+
+  end
+end