riveter 0.0.1

data/spec/examples/attribute_examples.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+shared_examples_for "an attribute" do |type, default_value, another_value, *args, &block|
+  options = args.extract_options!
+
+  describe type do
+    let(:name) { "a_#{type}" }
+    let(:instance) { subject.new() }
+
+    describe "as attribute" do
+      before do
+        subject.send :"attr_#{type}", name, *args, options
+      end
+
+      it { subject.attributes.should include(name.to_s) }
+      it { instance.attributes.should include(name.to_s) }
+      it { instance.should respond_to(name)}
+      it { instance.should respond_to("#{name}=")}
+
+      it "assigns attribute in initializer" do
+        a = subject.new(name => another_value)
+        a.send(name).should eq(another_value)
+        a.attributes[name].should eq(another_value)
+      end
+
+      it "assigns attribute" do
+        a = subject.new()
+        a.send("#{name}=", another_value)
+        a.attributes[name].should eq(another_value)
+      end
+    end
+
+    describe "as required attribute" do
+      before do
+        subject.send :"attr_#{type}", name, *args, options.merge(:required => true)
+      end
+
+      it { instance.should validate_presence_of(name)}
+    end
+
+    describe "with default value" do
+      before do
+        subject.send :"attr_#{type}", name, *args, options.merge(:default => default_value)
+      end
+
+      it { instance.send(name).should eq(default_value)}
+    end
+  end
+end
+
+shared_examples_for "a class with attributes" do |type|
+
+  # it's good enough to see whether the type includes
+  # the class methods of the attributes module
+  it { type.should be_a(Riveter::Attributes::ClassMethods) }
+
+end

data/spec/generators/haml/command_controller/command_controller_generator_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'generators/haml/command_controller/command_controller_generator'
+
+describe Haml::Generators::CommandControllerGenerator, :type => :generator do
+  it "creates the view with defaults" do
+    gen = generator %w(create_something)
+    expect(gen).to receive(:create_template_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates the view with specified action name" do
+    gen = generator %w(create_something create)
+    expect(gen).to receive(:create_template_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates the view with specified action name and attributes" do
+    gen = generator %w(create_something create name:string:required active:boolean other)
+    expect(gen).to receive(:create_template_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  describe "the generated files" do
+    before do
+      run_generator %w(create_something create name:string:required active:boolean other)
+    end
+
+    describe "the view" do
+      subject { file('app/views/create_something_command/create.html.haml') }
+
+      it { should exist }
+    end
+  end
+end

data/spec/generators/haml/enquiry_controller/enquiry_controller_generator_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'generators/haml/enquiry_controller/enquiry_controller_generator'
+
+describe Haml::Generators::EnquiryControllerGenerator, :type => :generator do
+  it "creates the view with defaults" do
+    gen = generator %w(list_something)
+    expect(gen).to receive(:create_template_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates the view with specified action name" do
+    gen = generator %w(list_something list)
+    expect(gen).to receive(:create_template_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates the view with specified action name and attributes" do
+    gen = generator %w(list_something list name:string:required active:boolean other)
+    expect(gen).to receive(:create_template_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  describe "the generated files" do
+    before do
+      run_generator %w(list_something list name:string:required active:boolean other)
+    end
+
+    describe "the view" do
+      subject { file('app/views/list_something_enquiry/list.html.haml') }
+
+      it { should exist }
+    end
+  end
+end

data/spec/generators/riveter/command/command_generator_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'generators/riveter/command/command_generator'
+require 'fileutils'
+
+describe Riveter::Generators::CommandGenerator, :type => :generator do
+  it "creates the command with defaults" do
+    gen = generator %w(create_something --no-command-controller)
+    expect(gen).to receive(:create_command_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates the command with specified attributes" do
+    gen = generator %w(create_something name:string:required active:boolean other --no-command-controller)
+    expect(gen).to receive(:create_command_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates a module file" do
+    gen = generator %w(test_ns/create_something name:string:required active:boolean other --no-command-controller)
+    expect(gen).to receive(:create_module_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates a locale file if it doesn't exist" do
+    gen = generator %w(create_something --no-command-controller)
+    expect(gen).to receive(:create_locale_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "skips creating a locale file if it exists" do
+    pending
+  end
+
+  describe "the generated files" do
+    describe "the command" do
+      before do
+        run_generator %w(create_something name:string:required active:boolean other --no-command-controller)
+      end
+
+      subject { file('app/commands/create_something_command.rb') }
+
+      it { should exist }
+    end
+
+    describe "the commands.en.yml locale" do
+      before do
+        FileUtils.mkdir_p(file('config/locales'))
+        File.open(file('config/locales/commands.en.yml'), 'w') {|f| f.write 'empty' }
+        run_generator %w(create_something name:string:required active:boolean other --no-command-controller)
+      end
+
+      subject { file('config/locales/commands.en.yml') }
+
+      it { should exist }
+      it { File.open(file('config/locales/commands.en.yml'), 'r') {|f| f.read }.should eq('empty') }
+    end
+  end
+end

data/spec/generators/riveter/query_filter/query_filter_generator_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'generators/riveter/query_filter/query_filter_generator'
+require 'fileutils'
+
+describe Riveter::Generators::QueryFilterGenerator, :type => :generator do
+  it "creates the query filter with defaults" do
+    gen = generator %w(active_items)
+    expect(gen).to receive(:create_query_filter_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates the query filter with specified attributes" do
+    gen = generator %w(active_items name:string:required active:boolean other)
+    expect(gen).to receive(:create_query_filter_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates a module file" do
+    gen = generator %w(test_ns/active_items name:string:required active:boolean other)
+    expect(gen).to receive(:create_module_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "creates a locale file if it doesn't exist" do
+    gen = generator %w(active_items)
+    expect(gen).to receive(:create_locale_file)
+    capture(:stdout) { gen.invoke_all }
+  end
+
+  it "skips creating a locale file if it exists" do
+    pending
+  end
+
+  describe "the generated files" do
+    describe "the query filter" do
+      before do
+        run_generator %w(active_items name:string:required active:boolean other)
+      end
+
+      subject { file('app/query_filters/active_items_query_filter.rb') }
+
+      it { should exist }
+    end
+
+    describe "the commands.en.yml locale" do
+      before do
+        FileUtils.mkdir_p(file('config/locales'))
+        File.open(file('config/locales/query_filters.en.yml'), 'w') {|f| f.write 'empty' }
+        run_generator %w(active_items name:string:required active:boolean other)
+      end
+
+      subject { file('config/locales/query_filters.en.yml') }
+
+      it { should exist }
+      it { File.open(file('config/locales/query_filters.en.yml'), 'r') {|f| f.read }.should eq('empty') }
+    end
+  end
+end

data/spec/riveter/associated_type_registry_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Riveter::AssociatedTypeRegistry do
+  subject do
+    Class.new().class_eval {
+      include Riveter::AssociatedTypeRegistry
+      self
+    }
+  end
+
+  describe "#container" do
+    it "should be itself" do
+      subject.container.should eq(subject)
+    end
+
+    let(:derived_class) {
+      Class.new(subject).class_eval {
+        register_type self, TestAssociatedClass
+        self
+      }
+    }
+
+    it "should be the base class for derived classes" do
+      derived_class.container.should eq(subject)
+    end
+  end
+
+  describe "#key_for" do
+    it "yields a key for a symbol" do
+      subject.key_for(:key).should eq(:key)
+    end
+
+    it "yields a key for a type" do
+      subject.key_for(TestAssociatedClass).should eq(:test_associated_class)
+    end
+  end
+
+  describe "#register_type" do
+    it "registers the type for the associated class" do
+      expect {
+        subject.register_type subject, TestAssociatedClass
+      }.to change(subject.registry, :length).by(1)
+    end
+  end
+
+  describe "#resolve_all" do
+    it "should yield an empty array for an unregistered type" do
+      subject.resolve_all(Class).should eq([])
+    end
+
+    let!(:derived_classes) {
+      2.times.collect {
+        Class.new(subject).class_eval {
+          register_type self, TestAssociatedClass
+          self
+        }
+      }
+    }
+
+    it "should yield array of types for a registered type" do
+      subject.resolve_all(TestAssociatedClass).should eq(derived_classes)
+    end
+  end
+
+  describe "#resolve" do
+    it "should yield nil for an unregistered type" do
+      subject.resolve(Class).should be_nil
+    end
+
+    let!(:derived_classes) {
+      2.times.collect {
+        Class.new(subject).class_eval {
+          register_type self, TestAssociatedClass
+          self
+        }
+      }
+    }
+
+    it "should yield the first associated type for a registered type" do
+      subject.resolve(TestAssociatedClass).should eq(derived_classes.first)
+    end
+  end
+
+  describe "#resolve!" do
+    it "should raise UnregisteredType for an unregistered type" do
+      expect {
+        subject.resolve!(Class)
+      }.to raise_error(Riveter::UnregisteredType)
+    end
+
+    it "should include the unknown type in the error" do
+      begin
+        subject.resolve!(Class)
+      rescue Exception => e
+        e.type.should eq(Class)
+      end
+    end
+
+    let!(:derived_class) {
+      Class.new(subject).class_eval {
+        register_type self, TestAssociatedClass
+        self
+      }
+    }
+
+    it "should not raise UnregisteredType for a registered type" do
+      expect {
+        subject.resolve!(TestAssociatedClass)
+      }.to_not raise_error
+    end
+  end
+
+  describe "#registry" do
+    let!(:first_class) do
+      Class.new().class_eval {
+        include Riveter::AssociatedTypeRegistry
+        self
+      }
+    end
+
+    let!(:second_class) do
+      Class.new().class_eval {
+        include Riveter::AssociatedTypeRegistry
+        self
+      }
+    end
+
+    let!(:derived_first_class) do
+      Class.new(first_class).class_eval {
+        register_type self, TestAssociatedClass
+        self
+      }
+    end
+
+    let!(:derived_second_class) do
+      Class.new(second_class).class_eval {
+        register_type self, TestAssociatedClass
+        self
+      }
+    end
+
+    describe "each type has an independant registry" do
+      it { first_class.registry.should_not eq(second_class.registry) }
+      it { derived_first_class.registry.should_not eq(derived_second_class.registry) }
+      it { derived_first_class.registry.should eq(first_class.registry) }
+      it { derived_second_class.registry.should eq(second_class.registry) }
+    end
+
+    describe "registered types" do
+      let(:key) { first_class.key_for(TestAssociatedClass) }
+
+      it { first_class.registry.key?(key).should be_true }
+      it { second_class.registry.key?(key).should be_true }
+      it { derived_first_class.registry.key?(key).should be_true }
+      it { derived_second_class.registry.key?(key).should be_true }
+    end
+  end
+end

data/spec/riveter/attribute_default_value_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Riveter::AttributeDefaultValues do
+  before do
+    TestModelWithAttributeDefaultValues.send :attr_accessor, :prop, :prop1, :prop2
+  end
+
+  describe "class" do
+    subject { TestModelWithAttributeDefaultValues }
+
+    describe "#default_value_for" do
+      it { should respond_to(:default_value_for) }
+
+      it "should register default value for given attribute" do
+        subject.default_value_for :prop, :value
+        subject.attribute_defaults[:prop].should eq(:value)
+      end
+
+      it "should register default value using a proc for given attribute" do
+        subject.default_value_for :prop do :value; end
+        subject.attribute_defaults[:prop].should be_a(Proc)
+      end
+
+      it "should have own registration" do
+        expect {
+          Class.new(ActiveRecord::Base).class_eval do |klass|
+            include Riveter::AttributeDefaultValues
+
+            attr_accessor :attr_name
+            default_value_for :attr_name, 1
+          end
+        }.to_not change { subject.attribute_defaults.length }
+      end
+    end
+
+    describe "#default_values" do
+      it { should respond_to(:default_values) }
+
+      it "should register multiple default values for given attributes" do
+        subject.default_values :prop1 => :value, :prop2 => :value
+        subject.attribute_defaults[:prop1].should eq(:value)
+        subject.attribute_defaults[:prop2].should eq(:value)
+      end
+
+      it "should register multiple default values using a procs for given attributes" do
+        subject.default_values :prop1 => lambda { :value }, :prop2 => lambda { :value }
+        subject.attribute_defaults[:prop1].should be_a(Proc)
+        subject.attribute_defaults[:prop2].should be_a(Proc)
+      end
+    end
+  end
+
+  describe "instance" do
+    before do
+      TestModelWithAttributeDefaultValues.default_values :prop1 => :value1, :prop2 => lambda {|*args| :value2 }
+    end
+
+    subject { TestModelWithAttributeDefaultValues.new() }
+
+    it { subject.prop1.should eq(:value1) }
+    it { subject.prop2.should eq(:value2) }
+
+    it "preserves existing attribute values" do
+      instance = TestModelWithAttributeDefaultValues.new(:prop1 => :valueA)
+      instance.prop1.should eq(:valueA)
+      instance.prop2.should eq(:value2)
+    end
+  end
+end