functio 0.1.0

data/test/test_expression.rb

@@ -0,0 +1,89 @@
+#--
+# Copyright (C) 2016  Cassiano Rocha Kuplich
+#
+# This file is part of Functio.
+#
+# Functio is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Functio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Functio.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'test_helper'
+require 'functio/errors'
+require 'functio/expression'
+require 'expression_interface_test'
+
+class TestExpression < Minitest::Test # :nodoc:
+  include ExpressionInterfaceTest
+
+  def setup
+    @object = Expression.new('42')
+  end
+
+  def test_instantiate_with_invalid_expressions
+    exprs = ['1 +', '3 $ 5', '1 2 3', '#@!', '', ' ', '  ']
+    exprs.each do |expr|
+      assert_raises(InvalidExpressionError) { Expression.new(expr) }
+    end
+  end
+
+  def test_instantiate_with_division_by_zero
+    exprs = ['1 / 0', '1 / (1 - 1)']
+    exprs.each do |expr|
+      assert_raises(DivisionByZeroError) do
+        Expression.new(expr)
+      end
+    end
+  end
+
+  def test_evaluate_expressions_with_no_variables
+    tests = { '1 + 1' => 2, '3.14 * 2' => 6.28, '42' => 42, '2 * (3 + 5)' => 16,
+              '-2 + 1' => -1 }
+    tests.each do |expr, expected|
+      assert_equal(expected, Expression.new(expr).evaluate)
+    end
+  end
+
+  def test_evaluate_expressions_with_variables
+    tests = { ['a + b', { a: 1, b: 2 }] => 3,
+              ['x * y', { x: 2, y: 3.14 }] => 6.28,
+              ['const', { const: 42 }] => 42 }
+    tests.each do |inputs, expected|
+      expression = Expression.new(inputs[0])
+      assert_equal(expected, expression.evaluate(inputs[1]))
+    end
+  end
+
+  def test_evaluate_with_wrong_list_of_variables
+    tests = { 'x' => {}, 'a + b' => { a: 1 }, 'x + y' => { y: 1 },
+              'y' => { x: 1 } }
+    tests.each do |expr, vars|
+      expression = Expression.new(expr)
+      assert_nil(expression.evaluate(vars))
+    end
+  end
+
+  def test_evaluate_division_by_zero
+    expression = Expression.new('1 / x')
+    assert_raises(DivisionByZeroError) do
+      expression.evaluate(x: 0)
+    end
+  end
+
+  def test_variables
+    tests = { 'a + b' => %w(a b), 'x' => ['x'], 'b / (a + b) * c' => %w(b a c),
+              '42' => [] }
+    tests.each do |expr, expected|
+      assert_equal(expected, Expression.new(expr).variables)
+    end
+  end
+end

data/test/test_formatted_num.rb

@@ -0,0 +1,56 @@
+#--
+# Copyright (C) 2016  Cassiano Rocha Kuplich
+#
+# This file is part of Functio.
+#
+# Functio is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Functio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Functio.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'test_helper'
+require 'bigdecimal'
+require 'functio/formatted_num'
+
+class TestFormattedNum < Minitest::Test # :nodoc:
+  def test_fixnum_format
+    test_data = [[123, '123'], [0, '0'], [-123, '-123']]
+    test_data.each do |input, expected|
+      assert_instance_of(Fixnum, input)
+      assert_equal(expected, FormattedNum.new(input).to_s)
+    end
+  end
+
+  def test_bignum_to_string
+    test_data = [
+      [12_345_678_901_234_567_890, '12345678901234567890'],
+      [-12_345_678_901_234_567_890, '-12345678901234567890']
+    ]
+    test_data.each do |input, expected|
+      assert_instance_of(Bignum, input)
+      assert_equal(expected, FormattedNum.new(input).to_s)
+    end
+  end
+
+  def test_bigdecimal_to_string
+    test_data = [
+      [BigDecimal.new('3.14'), '3.14'],
+      [BigDecimal.new('-3.14'), '-3.14'],
+      [BigDecimal.new('1234567.8901234567890'), '1234567.890123456789'],
+      [BigDecimal.new('0.00000001'), '0.00000001']
+    ]
+    test_data.each do |input, expected|
+      assert_instance_of(BigDecimal, input)
+      assert_equal(expected, FormattedNum.new(input).to_s)
+    end
+  end
+end

data/test/test_function.rb

@@ -0,0 +1,142 @@
+#--
+# Copyright (C) 2016  Cassiano Rocha Kuplich
+#
+# This file is part of Functio.
+#
+# Functio is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Functio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Functio.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'test_helper'
+require 'doubles/expression_double'
+require 'functio/errors'
+require 'functio/function'
+require 'storable_interface_test'
+
+class TestFunction < Minitest::Test # :nodoc:
+  include StorableInterfaceTest
+
+  def setup
+    @object = Function.new(name: 'test', expression: ExpressionDouble.new)
+  end
+
+  def test_build_function
+    function = Function.build(name: 'succ', definition: 'x + 1')
+    assert_instance_of(Function, function)
+    assert_equal('succ', function.name)
+    assert_equal('x + 1', function.definition)
+  end
+
+  def test_build_with_invalid_name
+    ['1abc', 'ab c', '+!@#'].each do |name|
+      ex = assert_raises(InvalidFunctionError) do
+        Function.build(name: name, definition: 'x + 1')
+      end
+      assert_equal('name must be alphanumeric and begin with a letter',
+                   ex.message)
+    end
+  end
+
+  def test_build_with_too_long_name
+    ex = assert_raises(InvalidFunctionError) do
+      Function.build(name: 'abcdefghijklmnopqrstu', definition: 'x + 1')
+    end
+    assert_equal(
+      "name size can't be greater than #{Function::MAX_NAME_SIZE} characters",
+      ex.message)
+  end
+
+  def test_build_with_invalid_definition
+    ex = assert_raises(InvalidFunctionError) do
+      Function.build(name: 'invalid', definition: 'x +')
+    end
+    assert_equal('definition must be a valid expression', ex.message)
+  end
+
+  def test_build_with_division_by_zero
+    ex = assert_raises(DivisionByZeroError) do
+      Function.build(name: 'divbyzero', definition: '1 / 0')
+    end
+    assert_equal('division by zero', ex.message)
+  end
+
+  def test_instantiate_with_invalid_name
+    ['1abc', 'ab c', '+!@#'].each do |name|
+      ex = assert_raises(InvalidFunctionError) do
+        expr_stub = ExpressionDouble.new(expression: 'a * b')
+        Function.new(name: name, expression: expr_stub)
+      end
+      assert_equal('name must be alphanumeric and begin with a letter',
+                   ex.message)
+    end
+  end
+
+  def test_instantiate_with_too_long_name
+    ex = assert_raises(InvalidFunctionError) do
+      expr_stub = ExpressionDouble.new(expression: 'a * b')
+      Function.new(name: 'abcdefghijklmnopqrstu', expression: expr_stub)
+    end
+    assert_equal(
+      "name size can't be greater than #{Function::MAX_NAME_SIZE} characters",
+      ex.message)
+  end
+
+  def test_attributes
+    expr_stub = ExpressionDouble.new(expression: 'a * b')
+    function = Function.new(name: 'test', expression: expr_stub)
+    assert_equal({ name: 'test', definition: 'a * b' }, function.attributes)
+  end
+
+  def test_equals_operator
+    add = function('add', 'a + b')
+    assert add == function('add', 'a + b')
+    refute add == function('sum', 'a + b')
+    refute add == function('add', 'x + y')
+    refute add == function('sum', 'x + y')
+  end
+
+  def test_function_params
+    expr_stub = ExpressionDouble.new(variables: %w(x y z))
+    function = Function.new(name: 'test', expression: expr_stub)
+    assert_equal(%w(x y z), function.params)
+  end
+
+  def test_use_function
+    expr_stub = ExpressionDouble.new(evaluate: -> { 42 })
+    function = Function.new(name: 'test', expression: expr_stub)
+    assert_equal(42, function.use('x' => 1))
+  end
+
+  def test_use_with_invalid_args
+    expr_stub = ExpressionDouble.new(evaluate: -> { nil })
+    function = Function.new(name: 'test', expression: expr_stub)
+    assert_equal(nil, function.use('x' => 1))
+    assert_equal(nil, function.use)
+  end
+
+  def test_use_with_division_by_zero
+    expr_stub = ExpressionDouble.new(evaluate: lambda do
+      raise DivisionByZeroError, 'division by zero'
+    end)
+    function = Function.new(name: 'test', expression: expr_stub)
+    ex = assert_raises(DivisionByZeroError) { function.use }
+    assert_equal('division by zero', ex.message)
+  end
+
+  private
+
+  def function(name, definition)
+    expr = ExpressionDouble.new(expression: definition)
+    Function.new(name: name, expression: expr)
+  end
+end

data/test/test_function_repository.rb

@@ -0,0 +1,97 @@
+#--
+# Copyright (C) 2016  Cassiano Rocha Kuplich
+#
+# This file is part of Functio.
+#
+# Functio is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Functio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Functio.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'test_helper'
+require 'doubles/function_double'
+require 'doubles/storage_double'
+require 'functio/function_repository'
+
+class TestFunctionRepository < Minitest::Test # :nodoc:
+  def test_add_new_function
+    storage_mock = Minitest::Mock.new
+    def storage_mock.find(_fields)
+      nil
+    end
+    storage_mock.expect :store, :return, [{ name: 'test', definition: 'a + b' }]
+    repo = FunctionRepository.new(storage: storage_mock)
+    function = FunctionDouble.build(name: 'test', definition: 'a + b')
+
+    assert repo.add(function)
+
+    storage_mock.verify
+  end
+
+  def test_add_function_with_existent_id
+    storage_double = StorageDouble.new(
+      find: { name: 'test', definition: 'a * b' })
+    repo = FunctionRepository.new(storage: storage_double)
+    function = FunctionDouble.build(name: 'test', definition: 'a + b')
+
+    refute repo.add(function)
+  end
+
+  def test_get_all_functions
+    stored = [{ name: 'add', definition: 'a + b' },
+              { name: 'sub', definition: 'a - b' }]
+    storage_double = StorageDouble.new(all: stored)
+    repo = FunctionRepository.new(storage: storage_double,
+                                  function_class: FunctionDouble)
+    expected = [FunctionDouble.build(stored[0]),
+                FunctionDouble.build(stored[1])]
+    assert_equal(expected, repo.all)
+  end
+
+  def test_get_all_with_empty_repository
+    storage_double = StorageDouble.new(all: [])
+    repo = FunctionRepository.new(storage: storage_double,
+                                  function_class: FunctionDouble)
+    assert_equal([], repo.all)
+  end
+
+  def test_find_function
+    record = { name: 'test', definition: 'a + b' }
+    storage_double = StorageDouble.new(find: record)
+    repo = FunctionRepository.new(storage: storage_double,
+                                  function_class: FunctionDouble)
+    assert_equal(FunctionDouble.build(record), repo.find('test'))
+  end
+
+  def test_find_inexistent_function
+    storage_double = StorageDouble.new(find: nil)
+    repo = FunctionRepository.new(storage: storage_double,
+                                  function_class: FunctionDouble)
+    assert_equal(nil, repo.find('test'))
+  end
+
+  def test_delete_function
+    storage_mock = Minitest::Mock.new
+    storage_mock.expect :delete, true, [{ name: 'test' }]
+    repo = FunctionRepository.new(storage: storage_mock)
+
+    assert repo.delete('test')
+    storage_mock.verify
+  end
+
+  def test_delete_inexistent_function
+    storage_double = StorageDouble.new(delete: false)
+    repo = FunctionRepository.new(storage: storage_double)
+
+    refute repo.delete('test')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+#--
+# Copyright (C) 2016  Cassiano Rocha Kuplich
+#
+# This file is part of Functio.
+#
+# Functio is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Functio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Functio.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'minitest/autorun'
+
+include Functio

data/test/test_licenses_compatibility.rb

@@ -0,0 +1,29 @@
+#--
+# Copyright (C) 2016  Cassiano Rocha Kuplich
+#
+# This file is part of Functio.
+#
+# Functio is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Functio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Functio.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'license_test_helper'
+
+class TestLicensesCompatibility < Minitest::Test # :nodoc:
+  def test_licenses_compatibility
+    validator = Papers::LicenseValidator.new
+
+    assert validator.valid?,
+           "License validation failed:\n#{validator.errors.join("\n")}"
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: functio
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cassiano Kuplich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dentaku
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.7
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+description: |
+  Functio is a calculator that allows you to create and manage functions for your
+  recurrent calculations.
+email: crkuplich@openmailbox.org
+executables:
+- fn
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- COPYING
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/fn
+- features/expression_evaluation.feature
+- features/function_creation.feature
+- features/function_deletion.feature
+- features/function_list.feature
+- features/function_use.feature
+- features/help_option.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+- features/support/functio_world.rb
+- features/version_option.feature
+- functio.gemspec
+- lib/functio.rb
+- lib/functio/data_storage.rb
+- lib/functio/errors.rb
+- lib/functio/expression.rb
+- lib/functio/formatted_num.rb
+- lib/functio/functio_cli.rb
+- lib/functio/function.rb
+- lib/functio/function_repository.rb
+- lib/functio/version.rb
+- test/doubles/expression_double.rb
+- test/doubles/function_double.rb
+- test/doubles/storage_double.rb
+- test/doubles/test_expression_double.rb
+- test/doubles/test_function_double.rb
+- test/doubles/test_storage_double.rb
+- test/expression_interface_test.rb
+- test/interface_test_helper.rb
+- test/license_test_helper.rb
+- test/storable_interface_test.rb
+- test/storage_interface_test.rb
+- test/test_data_storage.rb
+- test/test_expression.rb
+- test/test_formatted_num.rb
+- test/test_function.rb
+- test/test_function_repository.rb
+- test/test_helper.rb
+- test/test_licenses_compatibility.rb
+homepage: https://gitlab.com/functio/functio
+licenses:
+- GPL-3.0+
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.9
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Turn your recurrent calculations into functions
+test_files: []