RubyGems - veritas-optimizer - Versions diffs - 0.0.3 → 0.0.4 - Mend

veritas-optimizer 0.0.3 → 0.0.4

Files changed (349) hide show

@@ -1,26 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Connective::Negation::InvertibleOperand, '#optimizable?' do
-  subject { object.optimizable? }
-  let(:attribute) { Attribute::Integer.new(:id)              }
-  let(:negation)  { Logic::Connective::Negation.new(operand) }
-  let(:object)    { described_class.new(negation)            }
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Negation)
-  end
-  context 'when operand is invertible' do
-    let(:operand) { attribute.eq(1) }
-    it { should be(true) }
-  end
-  context 'when operand is not invertible' do
-    let(:operand) { proc { true } }
-    it { should be(false) }
-  end
-end

@@ -1,20 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Connective::Negation::InvertibleOperand, '#optimize' do
-  subject { object.optimize }
-  let(:attribute) { Attribute::Integer.new(:id)              }
-  let(:operand)   { attribute.eq(1)                          }
-  let(:negation)  { Logic::Connective::Negation.new(operand) }
-  let(:object)    { described_class.new(negation)            }
-  before do
-    object.should be_optimizable
-  end
-  it { should be_kind_of(Logic::Predicate::Inequality) }
-  its(:left) { should equal(attribute) }
-  its(:right) { should == 1 }
-end

@@ -1,20 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate, '.optimize_operand' do
-  subject { object.optimize_operand(predicate) }
-  let(:object) { Optimizer::Logic::Predicate }
-  context 'when optimizable' do
-    let(:optimized) { mock('Optimized')                           }
-    let(:predicate) { mock('Optimizable', :optimize => optimized) }
-    it { should equal(optimized) }
-  end
-  context 'when not optimizable' do
-    let(:predicate) { mock('Not Optimizable') }
-    it { should equal(predicate) }
-  end
-end

@@ -1,29 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate::ConstantOperands, '#optimizable?' do
-  subject { object.optimizable? }
-  let(:predicate) { Logic::Predicate::Equality.new(left, right) }
-  let(:object)    { described_class.new(predicate)              }
-  context 'when left and right are constants' do
-    let(:left)  { 1 }
-    let(:right) { 1 }
-    it { should be(true) }
-  end
-  context 'when left is a constant, and right is not a constant' do
-    let(:left)  { 1                                      }
-    let(:right) { Logic::Proposition::Tautology.instance }
-    it { should be(false) }
-  end
-  context 'when left is not a constant, and right is a constant' do
-    let(:left)  { Logic::Proposition::Tautology.instance }
-    let(:right) { 1                                      }
-    it { should be(false) }
-  end
-end

@@ -1,14 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate::ConstantOperands, '#optimize' do
-  subject { object.optimize }
-  let(:predicate) { Logic::Predicate::Equality.new(1, 1) }
-  let(:object)    { described_class.new(predicate)       }
-  before do
-    object.should be_optimizable
-  end
-  it { should equal(Logic::Proposition::Tautology.instance) }
-end

@@ -1,16 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate::Contradiction, '#optimize' do
-  subject { object.optimize }
-  let(:described_class) { Class.new(Optimizer::Logic::Predicate)                 }
-  let(:attribute)       { Attribute::Integer.new(:id)                            }
-  let(:predicate)       { Logic::Predicate::Inequality.new(attribute, attribute) }
-  let(:object)          { described_class.new(predicate)                         }
-  before do
-    described_class.class_eval { include Optimizer::Logic::Predicate::Contradiction }
-  end
-  it { should equal(Logic::Proposition::Contradiction.instance) }
-end

@@ -1,25 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate, '#left' do
-  subject { object.left }
-  let(:right)     { 'Right'                                      }
-  let(:predicate) { Class.new(Logic::Predicate).new(left, right) }
-  let(:object)    { described_class.new(predicate)               }
-  context 'when left operand is frozen' do
-    let(:left) { 'Left'.freeze }
-    it { should equal(left) }
-  end
-  context 'when left operand is not frozen' do
-    let(:left) { 'Left' }
-    it { should_not equal(left) }
-    it { should be_frozen }
-    it { should == left }
-  end
-end

@@ -1,25 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate, '#right' do
-  subject { object.right }
-  let(:left)      { 'Left'                                       }
-  let(:predicate) { Class.new(Logic::Predicate).new(left, right) }
-  let(:object)    { described_class.new(predicate)               }
-  context 'when right operand is frozen' do
-    let(:right) { 'Right'.freeze }
-    it { should equal(right) }
-  end
-  context 'when right operand is not frozen' do
-    let(:right) { 'Right' }
-    it { should_not equal(right) }
-    it { should be_frozen }
-    it { should == right }
-  end
-end

@@ -1,16 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate::Tautology, '#optimize' do
-  subject { object.optimize }
-  let(:described_class) { Class.new(Optimizer::Logic::Predicate)               }
-  let(:attribute)       { Attribute::Integer.new(:id)                          }
-  let(:predicate)       { Logic::Predicate::Equality.new(attribute, attribute) }
-  let(:object)          { described_class.new(predicate)                       }
-  before do
-    described_class.class_eval { include Optimizer::Logic::Predicate::Tautology }
-  end
-  it { should equal(Logic::Proposition::Tautology.instance) }
-end

@@ -1,19 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate::Util, '.max' do
-  subject { object.max(operand) }
-  let(:object) { Optimizer::Logic::Predicate::Util }
-  context 'with an attribute' do
-    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
-    it { should == 10 }
-  end
-  context 'with a constant' do
-    let(:operand) { 1 }
-    it { should == 1 }
-  end
-end

@@ -1,19 +0,0 @@
-require 'spec_helper'
-describe Optimizer::Logic::Predicate::Util, '.min' do
-  subject { object.min(operand) }
-  let(:object) { Optimizer::Logic::Predicate::Util }
-  context 'with an attribute' do
-    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
-    it { should == 1 }
-  end
-  context 'with a constant' do
-    let(:operand) { 1 }
-    it { should == 1 }
-  end
-end

data/tasks/quality/ci.rake DELETED Viewed

	@@ -1,2 +0,0 @@
1	- desc 'Heckle and run metrics'
2	- task :ci => [ :verify_measurements, :heckle, :flog, :flay, :reek, :roodi, 'metrics:all' ]