kitestrings 1.0.0

data/lib/generators/templates/views/layouts/application.html.haml

@@ -0,0 +1,23 @@
+!!! 5
+%html
+  %head
+    %meta{"name"=>"viewport", "content"=>"width=device-width", "initial-scale"=>1}
+    = csrf_meta_tag
+    = javascript_include_tag :application
+    = stylesheet_link_tag :application, media: 'all'
+
+    /[if lt IE 9]
+      = javascript_include_tag '//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7/html5shiv.min.js'
+  %body
+    .row
+      .col-md-12
+        .container
+          .row
+            = render 'navigation'
+          .row
+            - if alert
+              %p.alert= alert
+            - if notice
+              %p.notice= notice
+          .row
+            = yield

data/lib/kitestrings.rb

@@ -0,0 +1,6 @@
+require 'rails'
+require "kitestrings/version"
+require "kitestrings/railtie" if defined? Rails
+
+module Kitestrings
+end

data/lib/kitestrings/railtie.rb

@@ -0,0 +1,15 @@
+require 'kitestrings'
+require 'rails'
+module Kitestrings
+  class Railtie < ::Rails::Railtie
+    railtie_name :kitestrings
+
+    rake_tasks do
+      load "tasks/test_prepare_after_migrate.rake"
+    end
+
+    initializer 'kitestrings.autoload', :before => :set_autoload_paths do |app|
+      app.config.autoload_paths << File.expand_path("../../", __FILE__)
+    end
+  end
+end

data/lib/kitestrings/version.rb

@@ -0,0 +1,3 @@
+module Kitestrings
+  VERSION = "1.0.0"
+end

data/lib/page_and_sort_helper.rb

@@ -0,0 +1,99 @@
+module PageAndSortHelper
+
+  # read the sort column from the params hash, returning it as a symbol, or nil
+  # @return [Symbol]
+  def sort_column
+    params[:sort].try(:to_sym) || @_sort_order
+  end
+
+  # return the sort direction, defaulting to ascending, as a symbol. :asc or :desc
+  # @return [Symbol]
+  def sort_direction(default=nil)
+    direction = (params[:sort_direction] || @_sort_direction || default || :asc).to_sym
+    [:asc, :desc].include?(direction) ? direction : :asc
+  end
+
+  # create a link for the field by localising the field name and appending an up or down arrow indicating the current
+  # sort order if this field is the currently sorted field. The sort order in the link is opposite to the current
+  # sort order so that the user can toggle the sort order by clicking the link again.
+  #
+  # This defaults to looking up the field name on the class used in the controller for +page_and_sort+.
+  def sortable_title(field, options={})
+    klass = options[:class]
+    title = h(options[:title] || (klass || @_sort_klass).human_attribute_name(field))
+
+    direction = :asc
+    if sort_column == field
+      if sort_direction == :asc
+        title += " ↓".html_safe
+        direction = :desc
+      else
+        title += " ↑".html_safe
+      end
+    end
+
+    link_to title, params.merge(sort: field, sort_direction: direction)
+  end
+
+  module Controller
+
+    # return the given scope paged and sorted according to the query modifiers present in params. This includes:
+    # 1. Using kaminari for paging long lists.
+    # 2. Sorting the results by params[:sort] in the params[:sort_direction] direction (default to ASC)
+    #
+    # Note, complex order bys can be delegated to a class method (or scope) which will be passed the
+    # direction ("asc" or "desc"). The class method / scope should be named "order_by_" followed by the name of the
+    # sort.
+    #
+    # For example:
+    # class Model < ActiveRecord::Base
+    #   scope :order_by_complex_thing, lamda { |direction| order("complex order clause here") }
+    # end
+    #
+    # And use this by params[:sort] = "complex_thing"
+    def page_and_sort(scope, options={})
+
+      # get the ActiveRecord class for the scope.
+      klass =
+          case
+            when Array
+              scope
+            when scope.respond_to?(:scoped)
+              scope.scoped.klass
+            when ActiveRecord::Base
+              scope.all
+            else
+              scope
+          end
+
+      # save the sorting object class, so that it can be used as the localisation scope to look up the attribute
+      # name for the link
+      @_sort_klass = klass
+
+      # apply the order scope if present, prefering a class method / scope if defined, otherwise composing the clause
+      # using arel attributes so the sort order is safe to use with queries with joins, etc.
+      field = sort_column || options[:default_sort]
+      if field
+        # save the sort order in the controller's instance variables where it can be accessed by the view helper
+        # above to show the current sort order even if it is not specified by params[:sort]
+        @_sort_order = field
+        @_sort_direction = sort_direction(options[:default_direction])
+
+        scope =
+            if klass.respond_to? "order_by_#{field}"
+              scope.__send__ "order_by_#{field}", @_sort_direction
+            else
+              attribute = klass.arel_table[field]
+              scope.order(@_sort_direction == :asc ? attribute.asc : attribute.desc)
+            end
+      end
+
+      if options[:skip_pagination]
+        scope
+      else
+        # apply kaminari pagination
+        scope.page(params[:page])
+      end
+    end
+  end
+end

data/lib/size_validator.rb

@@ -0,0 +1,22 @@
+# A validator to validate the length of an array. Works on a collection proxy (has_many relationship) too.
+class SizeValidator < ActiveModel::EachValidator
+  # Validate the value is an Array and optionally that the number of items in it is at least a minimum or at most a
+  # maximum.
+  #
+  # Example:
+  #  validates :address_states, size: {min: 1, min_message: "must have at least 1 State selected"},
+  #
+  def validate_each(record, attribute, value)
+    if value.respond_to?(:size)
+      if options[:min].present? && value.size < options[:min]
+        record.errors.add attribute, options[:min_message] || "must have at least #{options[:min]} #{'item'.pluralize(options[:min])}"
+      end
+
+      if options[:max].present? && value.size > options[:max]
+        record.errors.add attribute, options[:max_message] || "must have at most #{options[:max]} #{'item'.pluralize(options[:max])}"
+      end
+    else
+      record.errors.add attribute, "must be sizeable"
+    end
+  end
+end

data/lib/tasks/test_prepare_after_migrate.rake

@@ -0,0 +1,11 @@
+namespace :db do
+  task :migrate do
+    Rake::Task["db:test:prepare"].invoke if Rails.env.development?
+  end
+
+  namespace :test do
+    task :prepare do
+      Rake::Task["db:fixtures:load"].invoke
+    end
+  end
+end

data/lib/uniqueness_without_deleted_validator.rb

@@ -0,0 +1,7 @@
+class UniquenessWithoutDeletedValidator < ActiveRecord::Validations::UniquenessValidator
+  protected
+
+  def build_relation(klass, table, attribute, value) #:nodoc:
+    super.and(table[klass.paranoia_column].eq(nil))
+  end
+end

data/spec/lib/array_validator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'active_support'
+require 'active_model'
+require 'array_validator'
+
+class ThingWithItems
+  include ActiveModel::Validations
+  attr_accessor :items
+
+  def initialize(items)
+    @items = items
+  end
+
+  validates :items, array: {min: 1, max: 5}
+end
+
+describe ArrayValidator do
+
+  before { subject.valid? }
+
+  context "validating an object with no items" do
+    subject { ThingWithItems.new(nil) }
+    it { expect(subject.errors[:items]).to include("must be an array") }
+  end
+
+  context "validating an object with an empty array" do
+    subject { ThingWithItems.new([])}
+    it { expect(subject.errors[:items]).to include("must have at least 1 item") }
+  end
+
+  context "validating an object with an empty array" do
+    subject { ThingWithItems.new([1,2,3,4,5,6])}
+    it { expect(subject.errors[:items]).to include("must have at most 5 items") }
+  end
+
+  context "validation passes" do
+    subject { ThingWithItems.new([1,2,3])}
+    it { expect(subject.errors[:items]).to be_empty }
+  end
+end

data/spec/lib/async_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'async'
+
+module ActiveRecord
+  class Base
+  end
+end
+
+describe Async do
+  class Example
+    include Async
+
+    attr :result
+
+    def calculate
+      async do
+        @result = Thread.current
+      end
+    end
+  end
+
+  before do
+    # stub active record for tests so we don't need a database connection.
+    pool = double("connection pool")
+    pool.stub(:with_connection).and_yield
+    ActiveRecord::Base.stub(:connection_pool => pool)
+  end
+
+  subject { Example.new }
+
+  it "done on same thread in tests" do
+    Thread.should_not_receive :new
+    subject.calculate
+    expect(subject.result).to eq(Thread.current)
+  end
+
+  it "done on a different thread" do
+    Async.stub :enabled => true
+    thread = subject.calculate
+    expect(thread).to be_a(Thread)
+    expect(thread).not_to eq(Thread.current)
+    thread.join
+    expect(subject.result).to eq(thread)
+  end
+
+  it "raises an exception if no block is given" do
+    expect { subject.async }.to raise_error(RuntimeError)
+  end
+end

data/spec/lib/generators/kitestrings/install_generator_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'fileutils'
+require 'generator_spec'
+require 'generators/kitestrings/install_generator'
+
+describe Kitestrings::Generators::InstallGenerator do
+  destination File.expand_path("../../../../tmp", __FILE__)
+
+  before :all do
+    prepare_destination
+    run_generator
+    @dir = self.class.test_case.destination_root
+  end
+
+  def file_path(path)
+    File.join(@dir, path)
+  end
+
+  def file_contents(path)
+    File.read(file_path(path))
+  end
+
+  context "check files" do
+    %w[
+        spec_ext/my_ip_spec.rb
+        spec_ext/spec_helper_ext.rb
+        config/deploy.rb
+        config/deploy/integ.rb
+        config/deploy/uat.rb
+        config/deploy/production.rb
+        lib/templates/haml/scaffold/_form.html.haml
+        lib/templates/haml/scaffold/edit.html.haml
+        lib/templates/haml/scaffold/index.html.haml
+        lib/templates/haml/scaffold/new.html.haml
+        lib/templates/haml/scaffold/show.html.haml
+        lib/templates/rails/scaffold_controller/controller.rb
+        lib/templates/rspec/helper/helper_spec.rb
+        lib/templates/rspec/integration/request.rb
+        lib/templates/rspec/model/model_spec.rb
+        lib/templates/rspec/scaffold/controller_spec.rb
+        lib/templates/rspec/scaffold/routing_spec.rb
+  ].each do |file|
+      it "created #{file}" do
+        path = File.join(@dir, file)
+        expect(File.exist?(path)).to be_truthy
+      end
+    end
+  end
+
+  # otherwise it wants to run the specs in the tmp/spec directory
+  after(:all) { rm_rf(@dir) }
+
+end

data/spec/lib/generators/kitestrings/messages_generator_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'fileutils'
+require 'generator_spec'
+require 'generators/kitestrings/messages_generator'
+require 'rails'
+
+describe Kitestrings::Generators::MessagesGenerator do
+  destination File.expand_path("../../../../tmp", __FILE__)
+
+  before :all do
+    prepare_destination
+    run_generator
+    @dir = self.class.test_case.destination_root
+  end
+
+  it do
+    expect(File.exist?(File.join(@dir, "app/models/message.rb")))
+  end
+end

data/spec/lib/page_and_sort_helper_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'page_and_sort_helper'
+require 'active_record'
+
+
+describe PageAndSortHelper do
+
+  # TODO: This spec file needs a test database to talk to. We don't have one set up for this gem yet.
+
+  class Record < ActiveRecord::Base
+  end
+
+  context "page_and_sort" do
+    let(:params) { {} }
+    let(:klass) do
+      Struct.new :params do
+        include PageAndSortHelper
+        include PageAndSortHelper::Controller
+      end
+    end
+    subject { klass.new(params) }
+
+    def scope_of(klass)
+      if ActiveRecord::VERSION::MAJOR >= 4
+        klass.all
+      else
+        klass.scoped
+      end
+    end
+    
+    context "record sort" do
+      let(:params) { {sort: "name", sort_direction: "asc"} }
+      it "on Record.scoped" do
+        scope = subject.page_and_sort(scope_of(Record))
+        expect(scope.to_sql).to include("ORDER BY `companies`.`name` ASC")
+      end
+      it "on Record" do
+        scope = subject.page_and_sort(Record)
+        expect(scope.to_sql).to include("ORDER BY `companies`.`name` ASC")
+      end
+      it "on Record.where" do
+        scope = subject.page_and_sort(Record.where("a = b"))
+        expect(scope.to_sql).to include("ORDER BY `companies`.`name` ASC")
+        expect(scope.to_sql).to include("a = b")
+      end
+    end
+    context "record sort desc" do
+      let(:params) { {sort: "name", sort_direction: "desc"} }
+      it "on Record.scoped" do
+        scope = subject.page_and_sort(scope_of(Record))
+        expect(scope.to_sql).to include("ORDER BY `companies`.`name` DESC")
+      end
+      it "on Record" do
+        scope = subject.page_and_sort(Record)
+        expect(scope.to_sql).to include("ORDER BY `companies`.`name` DESC")
+      end
+      it "on Record.where" do
+        scope = subject.page_and_sort(Record.where("a = b"))
+        expect(scope.to_sql).to include("ORDER BY `companies`.`name` DESC")
+        expect(scope.to_sql).to include("a = b")
+      end
+    end
+    context "record sort asc" do
+      let(:params) { {sort: "record_type", sort_direction: "asc"} }
+      it "on Record.scoped" do
+        scope = subject.page_and_sort(scope_of(Record))
+        expect(scope.to_sql).to match(/ORDER BY CASE genre_id .* END ASC/)
+      end
+      it "on Record" do
+        scope = subject.page_and_sort(Record)
+        expect(scope.to_sql).to match(/ORDER BY CASE genre_id .* END ASC/)
+      end
+      it "on Record.where" do
+        scope = subject.page_and_sort(Record.where("a = b"))
+        expect(scope.to_sql).to match(/ORDER BY CASE genre_id .* END ASC/)
+        expect(scope.to_sql).to include("a = b")
+      end
+    end
+    context "record sort desc" do
+      let(:params) { {sort: "record_type", sort_direction: "desc"} }
+      it "on Record.scoped" do
+        scope = subject.page_and_sort(scope_of(Record))
+        expect(scope.to_sql).to match(/ORDER BY CASE genre_id .* END DESC/)
+      end
+      it "on Record" do
+        scope = subject.page_and_sort(Record)
+        expect(scope.to_sql).to match(/ORDER BY CASE genre_id .* END DESC/)
+      end
+      it "on Record.where" do
+        scope = subject.page_and_sort(Record.where("a = b"))
+        expect(scope.to_sql).to match(/ORDER BY CASE genre_id .* END DESC/)
+        expect(scope.to_sql).to include("a = b")
+      end
+    end
+  end
+end