class_notes 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eab5805e4b978258c9dc4c0f1c59a5b319855db9
+  data.tar.gz: f9a5eecefd88a15d7385f07105653d65027bd947
+SHA512:
+  metadata.gz: a5b45f9cf7c20e3fc5515b8f0ee2ae35e8fe91a0b3151def792c0c0de5549758ba174f67cf0a32d8a2eb6ba289d1e6c2b9ac5af6b93057516fe66903e1f266ab
+  data.tar.gz: 58ecd321ecbddef2f8330382ccbaedcd0c74207a882ce67dd09de211fa7403312b1e81ded5153c1f12da27aecbd03857d87e8b0e25fe1a1e87288ccef2b8524d

data/README.md

@@ -0,0 +1,35 @@
+# class_notes
+make your classes take notes
+
+## install:
+    gem install class_notes
+
+## usage:
+
+```ruby
+require 'class_notes'
+
+class SimpleMath
+  def add(a:, b:)
+    a + b
+  end
+
+  def add_4(a:,b:,c:,d:)
+    add(a: add(a: a, b: b), b: add(a: c, b: d) )
+  end
+end
+
+notebook = ClassNotes.jot(SimpleMath).new
+notebook.add_4(a: 1, b: 2, c: 3, d: 4) # => 10
+puts notebook.notes # =>
+#SimpleMathNotebook
+#  add_4
+#    add
+#      {:args=>{:a=>"1", :b=>"2"}, :result=>3}
+#    add
+#      {:args=>{:a=>"3", :b=>"4"}, :result=>7}
+#    add
+#      {:args=>{:a=>"3", :b=>"7"}, :result=>10}
+#    {:args=>{:a=>"1", :b=>"2", :c=>"3", :d=>"4"}, :result=>10}
+#  {}
+```

data/lib/class_notes.rb

@@ -0,0 +1,21 @@
+require_relative 'class_notes/note'
+require_relative 'class_notes/notebook'
+
+module ClassNotes
+  ::Version = [1, 0, 0]
+
+  ## @brief create a new note taker Proc on parent
+  ## @param parent the parent note
+  ## @return a new Proc that can add notes to the parent
+  def self.note_taker(parent)
+    ->(note){ parent << note }
+  end
+
+  ## @brief wrap a class in notes
+  ## @param klass the class
+  ## @return a wrapped class
+  def self.jot(klass)
+    ClassNotes::Notebook.wrap_class(klass)
+  end
+
+end

data/lib/class_notes/note.rb

@@ -0,0 +1,73 @@
+module ClassNotes
+  ##
+  ## @brief      Class for a single step.
+  ##
+  class Note
+    attr_accessor :title, :data, :children
+
+    ##
+    ## @brief      makes a new note
+    ##
+    ## @param      title The title of the note
+    ## @param      data  The note's data
+    ##
+    ## @return     a new note object
+    ##
+    def initialize(title:, data:)
+      @children = []
+      @title    = title
+      @data     = data
+    end
+
+    ##
+    ## @brief      clears a notes children
+    ##
+    ## @return     []
+    ##
+    def reset!
+      @children = []
+    end
+
+    ##
+    ## @brief      add children
+    ##
+    ## @param other the child, can be either a note or a hash.  If a hash is
+    ##              given, a new note will be created using the hash as its
+    ##              arguments
+    ##
+    ## @return     []
+    ##
+    def <<(other)
+      case other
+      when Note
+        @children << other
+      when Hash
+        @children << Note.new(other)
+      end
+      @children.last
+    end
+
+    ## @brief render the note as a string
+    ## @param indent the indent level of the base string
+    ## @return String
+    def to_s(indent=0)
+      [
+        "#{"  " * indent}#{title}",
+        unless children.empty?
+          children.map { |child| child.to_s(indent+1) }.join("\n")
+        end,
+        "#{"  " * (indent+1)}#{data}"
+      ].compact.join("\n")
+    end
+
+    ## @brief render the note as a hash
+    ## @return Hash
+    def to_h
+      {
+        title: title,
+        children: children.empty? ? nil : children.map { |child| child.to_h },
+        data: data
+      }.compact
+    end
+  end
+end

data/lib/class_notes/notebook.rb

@@ -0,0 +1,58 @@
+module ClassNotes
+  module Notebook
+    ::WrappedSuffix = "Notebook"
+
+    ## @brief wrap a class in notes
+    ## @param klass the class
+    ## @return a copy of Klass with each of its methods wrapped
+    def self.wrap_class(klass)
+      notebook = Class.new(klass) {
+        include Notebook
+
+        attr_reader :notes, :add_note
+
+        def initialize
+          @notes    = ClassNotes::Note.new(title: self.class.to_s, data: {})
+          @add_note = ClassNotes.note_taker(notes)
+          wrap_methods(*self.class.superclass.instance_methods(false))
+        end
+      }
+
+
+      notebook_name = "#{klass.to_s}#{::WrappedSuffix}"
+      Object.const_set notebook_name, notebook
+
+      notebook
+    end
+
+    ## @brief wrap methods with notes
+    ## @param meths the methods to wrap
+    ## @return nil
+    def wrap_methods(*meths)
+      meths.each { |meth|
+        m = method(meth)
+        define_singleton_method(meth) { |*args, &block|
+
+          parent    = add_note
+          child     = add_note.({title: meth.to_s, data: {}})
+          @add_note = ClassNotes.note_taker(child)
+
+          result    = super(*args, &block)
+          @add_note = parent
+
+          pretty_args =
+            case args.first
+            when Hash
+              args.first.map { |t, v| [t, v.to_s]}.to_h
+            else
+              args
+            end
+
+          child.data = {args: pretty_args, result: result}
+
+          result
+        }
+      }
+    end
+  end
+end

data/test/simple_math.rb

@@ -0,0 +1,13 @@
+class SimpleMath
+  def add(a:, b:)
+    add_2(a, b)
+  end
+
+  def add_2(a, b)
+    a + b
+  end
+
+  def add_4(a:,b:,c:,d:)
+    add(a: add(a: a, b: b), b: add(a: c, b: d) )
+  end
+end

data/test/test_class_notes.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require_relative '../lib/class_notes'
+require_relative 'simple_math'
+
+class TestClassNotes < Test::Unit::TestCase
+
+  def setup
+    @notebook = ClassNotes.jot(SimpleMath).new
+  end
+
+  def teardown
+    Object.send(:remove_const, @notebook.class.to_s)
+  end
+
+  def test_notebook
+    [:add, :add_2, :add_4].each { |meth|
+      assert @notebook.respond_to? meth
+    }
+  end
+
+  def test_unobtrusiveness
+    assert_equal @notebook.add_4(a: 1, b: 2, c: 3, d: 4), 10
+  end
+
+  def test_penmanship
+    @notebook.add_4(a: 1, b: 2, c: 3, d: 4)
+    notes = @notebook.notes
+    assert_equal notes.title, "SimpleMathNotebook"
+    assert_equal notes.to_h[:children].first[:children][2][:children].first[:data][:args][1], 7
+  end
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: class_notes
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- annacrombie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-10 00:00:00.000000000 Z
+dependencies: []
+description: wrap a classes instance methods in logic that keeps track of their actions
+email: stone.tickle@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./README.md"
+- "./lib/class_notes.rb"
+- "./lib/class_notes/note.rb"
+- "./lib/class_notes/notebook.rb"
+- "./test/simple_math.rb"
+- "./test/test_class_notes.rb"
+homepage: https://github.com/uab-cs/class_notes/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: make your classes take notes
+test_files: []