obvious 0.0.8 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9a0c1346518213e685185d08916b2c573697ca5d6be5763f8cfe245febeac4f0
+  data.tar.gz: 2125df9f05284d2e34b16edb85ee14f73d1d1f2a296df90c7a2b4e2a795ab81f
+SHA512:
+  metadata.gz: 1f8684fe2bc370eb3d2cec4933e3281a00b0633a5829cdee580b36632d330e6b71ba605612bd1ef5f5cfa6884ed66369a50117f68d3b1a9a9ec73a0c3e5bdfda
+  data.tar.gz: f393f71805593ff5b748477ebe9486148c356fdb73b1fb09f108453611ceabf4cce982768914c10de719012b0782659bf57ab4e91357871173551d60fb4503ff

data/.github/workflows/obvious.yml

@@ -0,0 +1,19 @@
+name: obvious
+
+on: [push]
+
+jobs:
+  unit-tests:
+    strategy:
+      matrix:
+        ruby: [ 2.7, '3.0', 3.1 ]
+    name: Ruby ${{ matrix.ruby }} unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: |
+          ruby -Ilib:test test/*_test.rb

data/.gitignore

@@ -4,7 +4,6 @@
 .bundle
 .config
 .yardoc
-Gemfile.lock
 InstalledFiles
 _yardoc
 coverage

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.2.0]
+
+### Added
+
+### Changed
+
+- Updated README to be current
+- Removed generators from Obvious
+- Refactored Obvious::Obj#define to be simpler
+- Replaced RSPec with Minitest for testing
+
+### Fixed
+
+- Fixed namespace issues with Contract errors
+- Updated project URL on Rubygems listing

data/Gemfile.lock

@@ -0,0 +1,19 @@
+PATH
+  remote: .
+  specs:
+    obvious (0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  obvious!
+
+BUNDLED WITH
+   2.3.4

data/README.md

@@ -1,10 +1,9 @@
 # Obvious
 
-Obvious is an architecture framework. The goal is to provide architectural structure for a highly testable system that is 
-obvious to understand and where both the front end UI and back end infrastructure are treated as implementation details 
-independent of the app logic itself.
-
-You can get a full explanation of Obvious at http://obvious.retromocha.com
+Obvious is an architecture framework. The goal is to provide architectural
+structure for a highly testable system that is obvious to understand and where
+both the front end UI and back end infrastructure are treated as implementation
+details independent of the app logic itself.
 
 ## Installation
 
@@ -15,31 +14,3 @@ Add this line to your application's Gemfile:
 And then execute:
 
     $ bundle
-
-Or install it yourself as:
-
-    $ gem install obvious
-
-## Usage
-
-Obvious is designed to be used in two ways - as a gem you require in your Obvious projects and also as an Obvious project 
-generation tool. 
-
-The project generation tool is run by executing...
-
-    $ obvious generate 
-
-in a directory containing a decriptors directory. You can read more about descriptors on the Obvious page or see an example
-in the Obvious Status example app: https://github.com/RetroMocha/obvious_status. 
-
-Currently the footprint of the Obvious library is quite small. The most important things defined so far are the Contract class
-and the Hash.has_shape? method. The rest of what makes an Obvious app interesting is the structure itself, not the libraries Obvious
-provides.
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request

data/Rakefile

@@ -1 +1,9 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+task :default => :test

data/lib/obvious/contract.rb

@@ -1,166 +1,179 @@
-class Contract
-  @@disable_override = false
+module Obvious
 
-  # Provides a default empty array for method_added
-  # Overriden by self.contracts
-  def self.contract_list
-    []
-  end
-
-  # Public: Sets the contracts
-  #
-  # contracts - a list of contracts, as String or as Symbols.
-  #
-  # Examples
-  #
-  #   class FooJackContract < Contract
-  #     contracts :save, :get, :list
-  #
-  #   end
-  #
-  # Returns Nothing.
-  def self.contracts *contracts
-    singleton_class.send :define_method, :contract_list do
-      contracts
-    end
-  end
+  class Contract
+    @@disable_override = false
 
-  # Public: Defines a contract for a method
-  #
-  # method - a symbol representing the method name
-  # contract - a hash with the keys :input and :output holding the respective shapes.
-  #
-  # Examples
-  #
-  #   class FooJackContract < Contract
-  #
-  #     contract_for :save, {
-  #       :input  => Foo.shape,
-  #       :output => Foo.shape,
-  #     }
-  #
-  #   end
-  #
-  def self.contract_for method, contract
-    method_alias    = "#{method}_alias".to_sym
-    method_contract = "#{method}_contract".to_sym
-
-    define_method method_contract do |*args|
-      input = args[0]
-      call_method method_alias, input, contract[:input], contract[:output]
+    # Provides a default empty array for method_added
+    # Overriden by self.contracts
+    def self.contract_list
+      []
     end
 
-    contracts( *contract_list, method )
-  end
-
-  # This method will move methods defined in @contracts into new methods.
-  # Each entry in @contracts will cause the method with the same name to
-  # become method_name_alias and for the original method to point to
-  # method_name_contract.
-  def self.method_added name
-    unless @@disable_override
-      self.contract_list.each do |method|
-        if name == method.to_sym
-          method_alias = "#{method}_alias".to_sym
-          method_contract = "#{method}_contract".to_sym
-
-          @@disable_override = true # to stop the new build method
-          self.send :alias_method, method_alias, name
-          self.send :remove_method, name
-          self.send :alias_method, name, method_contract
-
-          @@disable_override = false
-        else
-          # puts self.inspect
-          # puts "defining other method #{name}"
-        end
+    # Public: Sets the contracts
+    #
+    # contracts - a list of contracts, as String or as Symbols.
+    #
+    # Examples
+    #
+    #   class FooJackContract < Contract
+    #     contracts :save, :get, :list
+    #
+    #   end
+    #
+    # Returns Nothing.
+    def self.contracts *contracts
+      singleton_class.send :define_method, :contract_list do
+        contracts
       end
     end
-  end
 
-  # This method is used as a shorthand to mak the contract method calling pattern more DRY
-  # It starts by checking if you are sending in input and if so will check the input shape for
-  # errors. If no errors are found it calls the method via the passed in symbol(method).
-  #
-  # Output checking is more complicated because of the types of output we check for. Nil is
-  # never valid output. If we pass in the output shape of true, that means we are looking for
-  # result to be the object True. If the output shape is an array, that is actually a shorthand
-  # for telling our output check to look at the output as an array and compare it to the shape
-  # stored in output_shape[0]. If we pass in the symbol :true_false it means we are looking for
-  # the result to be either true or false. The default case will just check if result has the shape
-  # of the output_shape.
-  def call_method method, input, input_shape, output_shape
-    if input != nil && input_shape != nil
-      has_shape, error_field = input.has_shape? input_shape, true
-      unless has_shape 
-        raise ContractInputError, "incorrect input data format field #{error_field}"
+    # Public: Defines a contract for a method
+    #
+    # method - a symbol representing the method name
+    # contract - a hash with the keys :input and :output holding the respective shapes.
+    #
+    # Examples
+    #
+    #   class FooJackContract < Contract
+    #
+    #     contract_for :save, {
+    #       :input  => Foo.shape,
+    #       :output => Foo.shape,
+    #     }
+    #
+    #   end
+    #
+    def self.contract_for method, contract
+      method_alias    = "#{method}_alias".to_sym
+      method_contract = "#{method}_contract".to_sym
+
+      define_method method_contract do |*args|
+        input = args[0]
+        call_method method_alias, input, contract[:input], contract[:output]
       end
 
-      result = self.send method, input
-    else
-      result = self.send method
+      contracts( *contract_list, method )
     end
 
-    # check output
-    # output should never be nil
-    if result == nil
-      raise ContractOutputError, 'incorrect output data format'
+    # This method will move methods defined in @contracts into new methods.
+    # Each entry in @contracts will cause the method with the same name to
+    # become method_name_alias and for the original method to point to
+    # method_name_contract.
+    def self.method_added name
+      unless @@disable_override
+        self.contract_list.each do |method|
+          if name == method.to_sym
+            method_alias = "#{method}_alias".to_sym
+            method_contract = "#{method}_contract".to_sym
+
+            @@disable_override = true # to stop the new build method
+            self.send :alias_method, method_alias, name
+            self.send :remove_method, name
+            self.send :alias_method, name, method_contract
+
+            @@disable_override = false
+          else
+            # puts self.inspect
+            # puts "defining other method #{name}"
+          end
+        end
+      end
     end
 
-    if result === {}
-      raise DataNotFoundError, 'data was not found'
-    end
+    # This method is used as a shorthand to mak the contract method calling pattern more DRY
+    # It starts by checking if you are sending in input and if so will check the input shape for
+    # errors. If no errors are found it calls the method via the passed in symbol(method).
+    #
+    # Output checking is more complicated because of the types of output we check for. Nil is
+    # never valid output. If we pass in the output shape of true, that means we are looking for
+    # result to be the object True. If the output shape is an array, that is actually a shorthand
+    # for telling our output check to look at the output as an array and compare it to the shape
+    # stored in output_shape[0]. If we pass in the symbol :true_false it means we are looking for
+    # the result to be either true or false. The default case will just check if result has the shape
+    # of the output_shape.
+    def call_method method, input, input_shape, output_shape
+      if input != nil && input_shape != nil
+        has_shape, error_field = input.has_shape? input_shape, true
+        unless has_shape
+          raise Obvious::ContractInputError, "incorrect input data format field #{error_field}"
+        end
 
-    # we are looking for result to be a True object
-    if output_shape === true
-      if output_shape == result
-        return result
+        result = self.send method, input
       else
-        raise ContractOutputError, 'incorrect output data format'
+        result = self.send method
+      end
+
+      # check output
+      # output should never be nil
+      if result == nil
+        raise Obvious::ContractOutputError, 'incorrect output data format'
+      end
+
+      if result === {}
+        raise Obvious::DataNotFoundError, 'data was not found'
+      end
+
+      # we are looking for result to be a True object
+      if output_shape === true
+        if output_shape == result
+          return result
+        else
+          raise Obvious::ContractOutputError, 'incorrect output data format'
+        end
       end
-    end
 
-    # we want to check the shape of each item in the result array
-    if output_shape.class == Array
-      if result.class == Array
-        inner_shape = output_shape[0]
-        result.each do |item|
-          has_shape, error_field = item.has_shape? inner_shape, true
-          unless has_shape 
-            raise ContractOutputError, "incorrect output data format field #{error_field}"
+      # we want to check the shape of each item in the result array
+      if output_shape.class == Array
+        if result.class == Array
+          inner_shape = output_shape[0]
+          result.each do |item|
+            has_shape, error_field = item.has_shape? inner_shape, true
+            unless has_shape
+              raise Obvious::ContractOutputError, "incorrect output data format field #{error_field}"
+            end
           end
+
+          return result
+        end
+        raise Obvious::ContractOutputError, 'incorrect output data format'
+      end
+
+      # we want result to be true or false
+      if output_shape == :true_false
+        unless result == true || result == false
+          raise Obvious::ContractOutputError, 'incorrect output data format'
         end
 
         return result
       end
-      raise ContractOutputError, 'incorrect output data format'
-    end
 
-    # we want result to be true or false
-    if output_shape == :true_false
-      unless result == true || result == false
-        raise ContractOutputError, 'incorrect output data format'
+      # we want result to be output_shape's shape
+      has_shape, error_field = result.has_shape? output_shape, true
+      unless has_shape
+        raise Obvious::ContractOutputError, "incorrect output data format field #{error_field}"
       end
 
-      return result
+      result
     end
 
-    # we want result to be output_shape's shape
-    has_shape, error_field = result.has_shape? output_shape, true
-    unless has_shape 
-      raise ContractOutputError, "incorrect output data format field #{error_field}"
-    end
+  end
+
+
+  class ContractInputError < StandardError
+  end
 
-    result
+  class ContractOutputError < StandardError
   end
 
+  class DataNotFoundError < StandardError
+  end
 end
 
 # via https://github.com/citizen428/shenanigans/blob/master/lib/shenanigans/hash/has_shape_pred.rb
 class Hash
   # Checks if a hash has a certain structure.
   #     h = { k1: 1, k2: "1" }
-  #     h.has_shape?(k1: Fixnum, k2: String)
+  #     h.has_shape?(k1: Integer, k2: String)
   #     #=> true
   #     h.has_shape?(k1: Class, k2: String)
   #     #=> false
@@ -174,28 +187,28 @@ class Hash
       if return_field
         return r, f
       else
-        return r 
+        return r
       end
     }
- 
+
     # I added an empty check
     if self.empty?
       return return_value.call shape.empty?, nil
-    end  
- 
+    end
+
     self.each do |k, v|
       return return_value.call false, k if shape[k] == nil
-    end 
+    end
 
     shape.each do |k, v|
       # hash_value
       hv = self[k]
-      return return_value.call false, k unless self.has_key? k 
+      return return_value.call false, k unless self.has_key? k
 
       next if hv === nil
 
-      if Hash === hv 
-        return hv.has_shape?(v, return_field) 
+      if Hash === hv
+        return hv.has_shape?(v, return_field)
       else
         return return_value.call false, k unless v === hv
       end
@@ -204,14 +217,11 @@ class Hash
     return_value.call true, nil
   end
 
-end
-
-class ContractInputError < StandardError
-end
-
-class ContractOutputError < StandardError
-end
+  def nil_fields? list
+    list.each do |field|
+      return true, field unless self[field]
+    end
 
-class DataNotFoundError < StandardError
+    return false, nil
+  end
 end
-

data/lib/obvious/obj.rb

@@ -0,0 +1,36 @@
+module Obvious
+  module Obj
+    class << self
+      def included(base)
+        base.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+
+      def define method, input = {}, &block
+        define_method(method) do |method_input = {}|
+          block_input = {}
+          method_input.each do |k,v|
+            if input[k].nil?
+              raise ArgumentError.new "invalid input field #{k}"
+            end
+
+            unless v.is_a? input[k]
+              raise ArgumentError.new "invalid type for #{k} expected #{input[k]}"
+            end
+          end
+
+          input.each do |k,v|
+            if method_input[k].nil?
+              raise ArgumentError.new "missing input field #{k}"
+            end
+          end
+
+          self.instance_exec method_input, &block
+        end
+      end
+
+    end
+  end
+end

data/lib/obvious/version.rb

@@ -1,3 +1,3 @@
 module Obvious
-  VERSION = "0.0.8"
+  VERSION = "0.2.0"
 end

data/lib/obvious.rb

@@ -1,4 +1,4 @@
 require 'obvious/version'
 require 'obvious/contract'
 require 'obvious/entity'
-require_relative 'generators/application_generator'
+require 'obvious/obj'

data/obvious.gemspec

@@ -6,16 +6,14 @@ require 'obvious/version'
 Gem::Specification.new do |gem|
   gem.name          = "obvious"
   gem.version       = Obvious::VERSION
-  gem.authors       = ["Brian Knapp"]
-  gem.email         = ["brianknapp@gmail.com"]
+  gem.authors       = ["Brian Knapp", "Shawn Baden"]
+  gem.email         = ["brianknapp@gmail.com", "shawnbaden@hotmail.com"]
   gem.description   = "A set of tools to build apps using the Obvious Architecture"
-  gem.summary       = "Isn't it Obvious?"
-  gem.homepage      = "http://obvious.retromocha.com/"
-
+  gem.summary       = "Clean Architecture framework"
+  gem.homepage      = "https://github.com/RetroMocha/obvious"
+  gem.license       = "MIT"
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-
-  gem.add_development_dependency "rspec"
 end

data/test/contract_test.rb

@@ -0,0 +1,62 @@
+require 'minitest/autorun'
+require_relative '../lib/obvious/contract'
+
+class TestContract < Obvious::Contract
+  contract_for :test, {
+    input: { id: Integer },
+    output: { id: Integer, value: String }
+  }
+
+  def test input
+    { id: 1, value: 'this is a test' }
+  end
+end
+
+class ContractTest < Minitest::Test
+  def test_valid_input
+    result = TestContract.new.test(id: 1)
+    assert_equal({id: 1, value: 'this is a test'}, result)
+  end
+
+  def test_invalid_input
+    assert_raises Obvious::ContractInputError do
+      TestContract.new.test(Hash.new)
+    end
+  end
+
+  def test_empty_hash_return
+    assert_raises Obvious::DataNotFoundError do
+      tc = TestContract.new
+      tc.stub :test_alias, {} do
+        tc.test(id: 1)
+      end
+    end
+  end
+
+  def test_nil_return
+    assert_raises Obvious::ContractOutputError do
+      tc = TestContract.new
+      tc.stub :test_alias, nil do
+        tc.test(id: 1)
+      end
+    end
+  end
+end
+
+class HashTest < Minitest::Test
+  def test_valid_has_shape
+    assert({id: 1}.has_shape?(id: Integer))
+  end
+
+  def test_invalid_has_shape
+    refute({id: 1}.has_shape?(id: String))
+  end
+
+  def test_has_shape_allow_nil_values
+    assert({id: nil}.has_shape?({id: String}))
+  end
+
+  def test_has_shape_return_invalid_field
+    assert_equal([false, :id], { id: 1 }.has_shape?({id: String}, true))
+  end
+end