obvious 0.0.7 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4bf4de686eee48c524a3037620e21a154db8c75fce3ff8db780afc25dc376202
+  data.tar.gz: c4930e55f1420a9b40996fc042052f267548b3f6017055ad69355c44bad28f7e
+SHA512:
+  metadata.gz: 377a83eba55eeadeb63bdadd1a12f72a81507b5d029486add3ffba65fd81c4de929936e435bc73ac0816185bab6dff2a0aa1b4ecfcf527fa36d4dbdc13abaf81
+  data.tar.gz: 6f7a51c4037baa95be253c62a801f1c8204e662b089bc45bd7f6db1df94f6c39d1130625fb745a7c558111662c5baeaf59372817a077f17d14faf7af2ce0b394

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: |
+          bundle exec rspec

data/.gitignore

@@ -1,9 +1,9 @@
 *.gem
 *.rbc
+*.swp
 .bundle
 .config
 .yardoc
-Gemfile.lock
 InstalledFiles
 _yardoc
 coverage

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    obvious (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  obvious!
+  rspec
+
+BUNDLED WITH
+   2.3.4

data/README.md

@@ -6,6 +6,16 @@ independent of the app logic itself.
 
 You can get a full explanation of Obvious at http://obvious.retromocha.com
 
+
+# Notice:
+
+This project is no longer under active development is only made available for historical purposes.
+
+Right now [Brian is working on a little of this](http://brianknapp.me/now/) and [Shawn is working on a little of that](http://shawnbaden.com/now/).
+
+Most of our spare energy goes to the [Unbranded Pocket Notebook](https://www.amazon.com/dp/B00ZGE1914/) and the [Unbranded Pocket Journal](https://www.amazon.com/dp/B016LB2XYW).
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -35,11 +45,3 @@ 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/lib/generators/application_generator.rb

@@ -30,7 +30,8 @@ module Obvious
 
           puts 'Creating actions from descriptors... ' unless descriptors.length.zero?
           descriptors.each do |file|
-            descriptor = Obvious::Generators::Descriptor.new file
+            yaml = YAML.load_file(file)
+            descriptor = Obvious::Generators::Descriptor.new yaml
             descriptor.to_file
           end
 
@@ -145,27 +146,27 @@ end
 
             output = %Q{require 'obvious'
 
-class #{k}Contract < Contract
+class #{k}Contract < Obvious::Contract
   #{contract_defs}
 end
 }
 
-            snake_name = name.gsub(/(.)([A-Z])/,'\1_\2').downcase
+            snake_name = k.gsub(/(.)([A-Z])/,'\1_\2').downcase
 
-            filename = "#{@app.dir}/contracts/#{snake_name}_jack_contract.rb"
+            filename = "#{@app.dir}/contracts/#{snake_name}_contract.rb"
             File.open(filename, 'w') {|f| f.write(output) }
 
-            output = %Q{require_relative '../../contracts/#{snake_name}_jack_contract'
+            output = %Q{require_relative '../../contracts/#{snake_name}_contract'
 
 describe #{k}Contract do
   #{method_specs}
 end
 }
 
-            filename = "#{@app.dir}/spec/contracts/#{snake_name}_jack_spec.rb"
+            filename = "#{@app.dir}/spec/contracts/#{snake_name}_spec.rb"
             File.open(filename, 'w') {|f| f.write(output) }
 
-            output = %Q{require_relative '../../contracts/#{snake_name}_jack_contract'
+            output = %Q{require_relative '../../contracts/#{snake_name}_contract'
 
 class #{k}Double
   def self.create behavior
@@ -187,7 +188,7 @@ class #{k}_BadOutput < #{k}Contract
 end
 }
 
-            filename = "#{@app.dir}/spec/doubles/#{snake_name}_jack_double.rb"
+            filename = "#{@app.dir}/spec/doubles/#{snake_name}_double.rb"
             File.open(filename, 'w') {|f| f.write(output) }
 
           end

data/lib/generators/descriptor.rb

@@ -4,22 +4,25 @@ require_relative 'helpers/application'
 
 module Obvious
   module Generators
+    class InvalidDescriptorError < StandardError; end
+
     class Descriptor
       def initialize descriptor
         @descriptor = descriptor
       end
 
       def to_file
-        action = YAML.load_file @descriptor
+        validate_descriptor
+        
         @jacks, @entities = {}, {}
         @code = ''
 
-        action['Code'].each do |entry|
+        @descriptor['Code'].each do |entry|
           write_comments_for entry
           process_requirements_for entry if entry['requires']
         end
 
-        write_action action
+        write_action
       end
 
       private
@@ -53,12 +56,12 @@ module Obvious
         end
       end # #process_requirements_for
 
-      def write_action action
+      def write_action
         jacks_data   = process_jacks
         requirements = require_entities
 
         output = %Q{#{requirements}
-class #{action['Action']}
+class #{@descriptor['Action']}
 
   def initialize #{jacks_data[:inputs]}
 #{jacks_data[:assignments]}  end
@@ -68,24 +71,24 @@ class #{action['Action']}
 end
 }
 
-        snake_name = action['Action'].gsub(/(.)([A-Z])/,'\1_\2').downcase
+        snake_name = @descriptor['Action'].gsub(/(.)([A-Z])/,'\1_\2').downcase
 
         filename = "#{Obvious::Generators::Application.instance.dir}/actions/#{snake_name}.rb"
         File.open(filename, 'w') {|f| f.write(output) }
 
-  output = %Q{require_relative '../../actions/#{snake_name}'
+        output = %Q{require_relative '../../actions/#{snake_name}'
 
-describe #{action['Action']} do
+describe #{@descriptor['Action']} do
 
-  it '#{action['Description']}'
+  it '#{@descriptor['Description']}'
 
   it 'should raise an error with invalid input'
 
 end
-}
+        }
 
-  filename = "#{Obvious::Generators::Application.instance.dir}/spec/actions/#{snake_name}_spec.rb"
-  File.open(filename, 'w') {|f| f.write(output) }
+        filename = "#{Obvious::Generators::Application.instance.dir}/spec/actions/#{snake_name}_spec.rb"
+        File.open(filename, 'w') {|f| f.write(output) }
       end
 
       def process_jacks
@@ -116,6 +119,13 @@ end
 
         entity_requires
       end
+
+      def validate_descriptor
+        raise InvalidDescriptorError unless @descriptor
+        raise InvalidDescriptorError if @descriptor['Code'].nil?
+        raise InvalidDescriptorError if @descriptor['Action'].nil?
+        raise InvalidDescriptorError if @descriptor['Description'].nil?
+      end
     end # ::Descriptor
   end
 end

data/lib/obvious/contract.rb

@@ -1,150 +1,161 @@
-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
-      unless input.has_shape? input_shape
-        raise ContractInputError, 'incorrect input data format'
+    # 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
 
-    # we are looking for result to be a True object
-    if output_shape === true
-      if output_shape == result
-        return result
+    # 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}"
+        end
+
+        result = self.send method, input
       else
+        result = self.send method
+      end
+
+      # check output
+      # output should never be nil
+      if result == nil
         raise ContractOutputError, 'incorrect output data format'
       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|
-          unless item.has_shape? inner_shape
-            raise ContractOutputError, 'incorrect output data format'
+      if result === {}
+        raise 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 ContractOutputError, 'incorrect output data format'
+        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}"
+            end
           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'
         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 ContractOutputError, "incorrect output data format field #{error_field}"
       end
 
-      return result
-    end
-
-    # we want result to be output_shape's shape
-    unless result.has_shape? output_shape
-      raise ContractOutputError, 'incorrect output data format'
+      result
     end
 
-    result
   end
 
 end
@@ -153,7 +164,7 @@ end
 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
@@ -162,17 +173,47 @@ class Hash
   #     shape = { k1: Array, k2: { k3: Module } }
   #     h.has_shape?(shape)
   #     #=> true
-  def has_shape?(shape)
+  def has_shape?(shape, return_field = false)
+    return_value = lambda { |r, f|
+      if return_field
+        return r, f
+      else
+        return r 
+      end
+    }
+ 
     # I added an empty check
     if self.empty?
-      return shape.empty?
-    end
-
-    shape.all? do |k, v|
+      return return_value.call shape.empty?, nil
+    end  
+ 
+    self.each do |k, v|
+      return return_value.call false, k if shape[k] == nil
+    end 
+
+    shape.each do |k, v|
       # hash_value
       hv = self[k]
-      Hash === hv ? hv.has_shape?(v) : v === hv
+      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) 
+      else
+        return return_value.call false, k unless v === hv
+      end
     end
+
+    return_value.call true, nil
+  end
+
+  def nil_fields? list
+    list.each do |field|
+      return true, field unless self[field]
+    end  
+    
+    return false, nil
   end
 end
 
@@ -181,3 +222,7 @@ end
 
 class ContractOutputError < StandardError
 end
+
+class DataNotFoundError < StandardError
+end
+

data/lib/obvious/entity.rb

@@ -0,0 +1,74 @@
+
+module Obvious
+
+  module EntityMixin 
+    class << self
+      def included(base)
+        base.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      attr_reader :shape
+      attr_reader :validations
+
+      def value name, type 
+        name = name.to_sym
+        @shape ||= {}
+        @shape[name] = type   
+        define_method(name) { @values[name] }
+      end
+
+      def validation name, method
+        name = "#{name}_validation".to_sym
+        @validations ||= [] 
+        @validations << name 
+        define_method(name) { instance_exec &method }
+      end
+    end
+  end
+
+  class ShapeError < StandardError; end
+  class TypeError < StandardError; end
+  class ValidationError < StandardError; end
+
+  class Entity
+    include EntityMixin
+
+    def initialize input
+      shape = self.class.shape
+      validations = self.class.validations || []
+      
+      self.class.shape.freeze
+      self.class.validations.freeze
+
+      @values = {}
+      input.each do |k, v|
+        unless shape[k]
+          raise Obvious::ShapeError.new "Invalid input field: #{k}" 
+        else
+          @values[k] = v
+        end
+      end 
+      
+      @values.freeze # this might need to be recursive?
+
+      shape.each do |k, v|
+        unless @values[k].class == v
+          msg = "Validation Error: Invalid value for #{k}, should be a #{v}"
+          raise Obvious::TypeError.new msg 
+        end
+      end
+
+      validations.each { |method| send method } 
+
+      freeze
+    end 
+
+    def to_hash
+      {}.tap {|h| @values.each { |k, v| h[k] = v } }
+    end
+
+  end
+end
+

data/lib/obvious/files/external/fs_plug.rb

@@ -6,13 +6,19 @@ class FsPlug
     @filename = filename
   end
 
-  def save input
-    # open the file
+  def load_data
     contents = File.read @filename
+    JSON.parse contents, :symbolize_names => true
+  end
 
+  def save_data input
+    json_data = JSON.pretty_generate input 
+    File.open(@filename, 'w') {|f| f.write(json_data) }
+  end
+
+  def save input
     data = []
-    # parse the json list
-    query = JSON.parse contents, :symbolize_names => true
+    query = load_data 
 
     new_element = true if input[:id] == -1 # by convention set new element flag if id == -1
 
@@ -27,51 +33,37 @@ class FsPlug
     end
 
     # add data to the list if it's a new element 
-    input[:id] = max_id + 1
-    data << input if new_element
+    if new_element 
+      input[:id] = max_id + 1
+      data << input 
+    end
 
-    # save the data back to FS
-    json_data = JSON.pretty_generate data 
-    File.open(@filename, 'w') {|f| f.write(json_data) }
+    save_data data
 
     # return the transformed data
     input
   end
 
   def list
-    # open the file
-    contents = File.read @filename
-
-    # parse the json list
-    data = JSON.parse contents, :symbolize_names => true
-    
-    # return the transformed data
-    data 
+    load_data
   end
   
   def get input
-    # open the file
-    contents = File.read @filename
-
     data = []
-    # parse the json list
-    query = JSON.parse contents, :symbolize_names => true
+    query = load_data 
 
     # transform the data if needed
     query.each do |h|
       return h if h[:id] == input[:id]
     end 
 
-    {} 
+    raise Exception.new 'no object found'
   end
 
   def remove input
-    # open the file
-    contents = File.read @filename
-
     data = []
     # parse the json list
-    query = JSON.parse contents, :symbolize_names => true
+    query = load_data 
 
     # transform the data if needed
     query.each do |h|
@@ -80,15 +72,28 @@ class FsPlug
       end
     end
 
-    # save the data back to FS
-    json_data = JSON.pretty_generate data 
-    File.open(@filename, 'w') {|f| f.write(json_data) }
+    save_data data
 
     # return true on success
     true 
   end
 
+  def find input
+    data = []
+    query = load_data 
+ 
+    key = input.keys[0] 
+ 
+    query.each do |h|
+      if input[key] == h[key]
+        return h
+      end
+    end 
+
+    raise Exception.new 'no object found'
+  end
 end
 
 
 
+

data/lib/obvious/files/external/mongo_plug.rb

@@ -1,5 +1,10 @@
 require 'moped'
 
+# To get the mongo system to work you need to have a counters collection. The
+# code here will increment the seq field which we use to set the id. If you are
+# having problems, you probably need to create the collection and add entries
+# for each other collection you want to have an id sequence.
+
 class MongoPlug
   def initialize collection
     @collection = collection

data/lib/obvious/files/external/s3_plug.rb

@@ -0,0 +1,94 @@
+require 'json'
+require 'aws/s3'
+
+class S3Plug
+  include AWS::S3
+
+  def initialize input 
+    @filename = input[:filename]
+    @bucket = input[:bucket]
+
+    # you can test locally with the fake-s3 gem: https://github.com/jubos/fake-s3
+    # or just swap out for the filesystem plug locally
+    s3_key = ENV['S3_KEY'] || '123'
+    s3_secret = ENV['S3_SECRET'] || 'abc'
+    s3_server = ENV['S3_SERVER'] || '0.0.0.0'
+    s3_port = ENV['S3_PORT'] || '10001'
+
+    AWS::S3::Base.establish_connection!(:access_key_id => s3_key,
+                                        :secret_access_key => s3_secret,
+                                        :server => s3_server,
+                                        :port => s3_port)
+  end
+
+  def load_data
+    contents = S3Object.value @filename, @bucket
+    JSON.parse contents, :symbolize_names => true
+  end
+
+  def save_data data
+    json_data = JSON.pretty_generate data 
+    S3Object.store @filename, json_data, @bucket
+  end
+
+  def save input
+    data = []
+    result = load_data
+    new_element = true if input[:id] == -1 # by convention set new element flag if id == -1
+
+    max_id = -1
+    # transform the data if needed
+    result.each do |h|
+      if input[:id] == h[:id]
+        h = input
+      end
+      max_id = h[:id] if h[:id] > max_id
+      data << h
+    end
+
+    # add data to the list if it's a new element 
+    if new_element
+      input[:id] = max_id + 1
+      data << input
+    end
+   
+    save_data data 
+
+    # return the transformed data
+    input
+  end
+
+  def list
+    load_data 
+  end
+  
+  def get input
+    data = []
+    result = load_data
+
+    # transform the data if needed
+    result.each do |h|
+      return h if h[:id] == input[:id]
+    end 
+
+    {} 
+  end
+
+  def remove input
+    data = []
+    result = load_data
+
+    # transform the data if needed
+    result.each do |h|
+      unless h[:id] == input[:id]
+        data << h 
+      end
+    end
+
+    save_data data
+
+    # return true on success
+    true 
+  end
+end
+

data/lib/obvious/obj.rb

@@ -0,0 +1,38 @@
+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][1]
+              raise ArgumentError.new "invalid type for #{k} expected #{input[k][1]}"
+            end 
+
+            block_input[input[k][0]] = v
+          end
+   
+          input.each do |k,v|
+            if block_input[v[0]].nil?
+              raise ArgumentError.new "missing input field #{k}"
+            end
+          end
+
+          self.instance_exec block_input, &block 
+        end
+      end
+
+    end
+  end
+end

data/lib/obvious/version.rb

@@ -1,3 +1,3 @@
 module Obvious
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
 end

data/lib/obvious.rb

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

data/obvious.gemspec

@@ -9,11 +9,13 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Brian Knapp"]
   gem.email         = ["brianknapp@gmail.com"]
   gem.description   = "A set of tools to build apps using the Obvious Architecture"
-  gem.summary       = "Isn't it Obvious?"
+  gem.summary       = "Clean Architecture framework"
   gem.homepage      = "http://obvious.retromocha.com/"
 
   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/spec/contract_spec.rb

@@ -0,0 +1,63 @@
+require_relative 'spec_helper'
+require_relative '../lib/obvious/contract'
+
+
+describe Hash do
+  describe '#has_shape?' do
+    it 'should return true for a valid shape' do
+      expect({ id: 1 }.has_shape?(id: Integer)).to be true
+    end
+    
+    it 'should return false for an invalid shape' do
+      expect({ id: 1 }.has_shape?(id: String)).to be false
+    end
+
+    it 'should retrn the invalid field if return_field flag is set' do
+      expect({ id: 1 }.has_shape?({id: String}, true)).to eq [false, :id]
+    end
+
+    it 'should allow for nil values to be returned' do
+      expect({ id: nil }.has_shape?({id: String})).to be true
+    end 
+  end
+end
+
+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
+
+describe Obvious::Contract do
+
+  describe "#call_method" do
+    it 'should return the correct output for valid input and output shapes' do
+      tc = TestContract.new
+      result = tc.test id: 1
+      expect(result).to eq id: 1, value: 'this is a test'
+    end
+  
+    it 'should raise a contract input error with bad input' do
+      tc = TestContract.new
+      expect { tc.test Hash.new }.to raise_error ContractInputError
+    end
+
+    it 'should raise a DataNotFound error if {} is returned' do
+      tc = TestContract.new
+      allow(tc).to receive(:test_alias).and_return({}) 
+      expect { tc.test id: 1 }.to raise_error DataNotFoundError
+    end
+
+    it 'should raise a contract output error if nil is returned' do
+      tc = TestContract.new
+      allow(tc).to receive(:test_alias).and_return(nil) 
+      expect { tc.test id: 1 }.to raise_error ContractOutputError
+    end
+
+  end
+end

data/spec/entity_spec.rb

@@ -0,0 +1,75 @@
+require_relative '../lib/obvious/entity'
+
+class Thing < Obvious::Entity
+  value :id, Integer 
+  value :name, String 
+end
+
+class Thing2 < Obvious::Entity
+  value :foo , String
+
+  validation :something, Proc.new {
+    if foo != "hello world"
+      msg = "Validation Error: Invalid value for foo, should be 'hello world'"
+      raise Obvious::ValidationError.new msg 
+    end
+  }
+
+  def modify_foo 
+    @values[:foo] = 100
+  end
+
+end
+
+class Thing3 < Obvious::Entity
+  value :foo , String
+
+  validation :something, Proc.new {
+    @values[:foo] = 12
+  }
+
+end
+
+# To test the entity, we are going to use classes that inherit from it instead
+# of poking at it directly. In this case, I think that makes the most sense.
+describe Thing do
+  it 'should create a valid object with valid input' do
+    input = { name: 'Thing', id: 1 }
+    t = Thing.new input
+    expect(t.name).to eq 'Thing'
+    expect(t.id).to eq 1
+  end
+
+  it 'should raise an error with invalid input types' do
+    input = { name: nil, id: nil }
+    expect { Thing.new input }.to raise_error Obvious::TypeError
+  end
+
+  it 'should raise an error with extra fields in input' do
+    input = { name: 'Thing', id: 1, extra: 'should explode' }
+    expect { Thing.new input }.to raise_error Obvious::ShapeError
+  end
+
+  it 'should raise an error when a method tries to modify a value' do
+    t = Thing2.new foo: 'hello world'
+    expect { t.modify_foo }.to raise_error RuntimeError
+  end
+
+  describe '#to_hash' do
+    it 'should return a hash representation of the object' do
+      input = { name: 'Thing', id: 1 }
+      t = Thing.new input
+      expect(t.to_hash).to eq input
+    end
+  end
+
+  describe 'validation' do
+    it 'should raise a validation error on a failed validation' do
+      expect { Thing2.new foo: 'not valid I promise!' }.to raise_error Obvious::ValidationError
+    end
+    
+    it 'should raise an error when trying to modify an object in a validation' do
+      expect { Thing3.new foo: 'hello world' }.to raise_error RuntimeError
+    end
+  end
+end

data/spec/generators/descriptor_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../../lib/generators/descriptor'
+
+require File.expand_path('spec/spec_helper')
+
+module Obvious
+  module Generators
+    describe Descriptor do
+      subject {Descriptor.new(yaml_file)}
+
+      describe "#to_file" do
+       
+        context "when the descriptor is empty" do
+          let( :yaml_file ) { {} }
+
+          it "should raise a meaningful error" do
+           expect {subject.to_file}.to raise_error(InvalidDescriptorError)
+          end
+        end
+
+        ["Action", "Code", "Description"].each do |section|
+          context "when the '#{section}' section is omitted" do
+            let( :yaml_file ) {
+              {"Action" => "Jackson", "Description" => "This is something"}.delete(section)
+            }
+
+            it "should raise a meaningful error" do
+              expect {subject.to_file}.to raise_error(InvalidDescriptorError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/obj_spec.rb

@@ -0,0 +1,64 @@
+require_relative '../lib/obvious/obj'
+
+class TestObj
+  include Obvious::Obj 
+
+  def initialize 
+    @local = 'set!'
+  end
+
+  define :defined_method, with_foo: [:foo, String], also_bar: [:bar, Integer] do |input|
+    input
+  end
+
+  define :defined_local do |input|
+    @local
+  end
+
+end
+
+describe Obvious::Obj do
+
+  before do
+    @test = TestObj.new
+  end
+
+  describe 'self.define' do
+    it 'should do the right thing with correct input' do
+      result = @test.defined_method with_foo: 'hello', also_bar: 12
+      expect(result).to eq foo: 'hello', bar: 12
+    end
+
+    it 'should have access to instance variables' do
+      result = @test.defined_local
+      expect(result).to eq 'set!' 
+    end
+
+    it 'should raise an error for missing parameters' do
+      expect { @test.defined_method with_foo: 'hello' }.to raise_error { |error| 
+        expect(error).to be_a ArgumentError
+        expect(error.message).to eq 'missing input field also_bar'
+      }
+    end
+
+    it 'should raise an error for extra parameters' do
+      expect { @test.defined_method with_foo: 'hello', also_bar: 12, and_extra: 'this is extra!' }.to raise_error { |error|
+        expect(error).to be_a ArgumentError
+        expect(error.message).to eq 'invalid input field and_extra'
+      }
+    end
+
+    it 'should raise an error for invalid types' do
+      expect { @test.defined_method with_foo: 1, also_bar: 12 }.to raise_error { |error|
+        expect(error).to be_a ArgumentError 
+        expect(error.message).to eq 'invalid type for with_foo expected String'
+      }
+
+      expect {@test.defined_method with_foo: 'hello', also_bar: nil }.to raise_error { |error|
+        expect(error).to be_a ArgumentError
+        expect(error.message).to eq 'invalid type for also_bar expected Integer'
+      } 
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |c|
+  c.mock_with :rspec 
+end

metadata

@@ -1,16 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: obvious
 version: !ruby/object:Gem::Version
-  version: 0.0.7
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Brian Knapp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-19 00:00:00.000000000 Z
-dependencies: []
+date: 2022-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A set of tools to build apps using the Obvious Architecture
 email:
 - brianknapp@gmail.com
@@ -19,8 +32,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".github/workflows/obvious.yml"
+- ".gitignore"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -30,35 +45,47 @@ files:
 - lib/generators/helpers/application.rb
 - lib/obvious.rb
 - lib/obvious/contract.rb
+- lib/obvious/entity.rb
 - lib/obvious/files/Rakefile
 - lib/obvious/files/external/fs_plug.rb
 - lib/obvious/files/external/mongo_plug.rb
 - lib/obvious/files/external/mysql_plug.rb
+- lib/obvious/files/external/s3_plug.rb
+- lib/obvious/obj.rb
 - lib/obvious/version.rb
 - obvious.gemspec
+- spec/.spec_helper.rb.swp
+- spec/contract_spec.rb
+- spec/entity_spec.rb
+- spec/generators/descriptor_spec.rb
+- spec/obj_spec.rb
+- spec/spec_helper.rb
 homepage: http://obvious.retromocha.com/
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 3.0.3
 signing_key: 
-specification_version: 3
-summary: Isn't it Obvious?
-test_files: []
-has_rdoc: 
+specification_version: 4
+summary: Clean Architecture framework
+test_files:
+- spec/.spec_helper.rb.swp
+- spec/contract_spec.rb
+- spec/entity_spec.rb
+- spec/generators/descriptor_spec.rb
+- spec/obj_spec.rb
+- spec/spec_helper.rb