taxon.benforeva 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35053bb03dec9130af32c823e454b4325a11ad86
+  data.tar.gz: 88ac8249d3e574ef092dc944cdb2ed77601d816e
+SHA512:
+  metadata.gz: c788f1f9686e6b6026e14adbf228d05634634bf89928385935f326b0db7e38d7d7dd772bb938f3aff2a01bf8a98a62801e33478a30bc69a0669b87923233c4c1
+  data.tar.gz: f6466dbed1e9c20a94a784daa8bdda2bc6668b92e47b2073fed2b392457092db35e5db591cd25e36fb15f89680bf38a73d79fdcbff8a37bd54b71e3f08bb4572

data/lib/taxon.rb

@@ -0,0 +1,15 @@
+require_relative 'taxon/primitives.rb'
+require_relative 'taxon/guard.rb'
+require_relative 'taxon/tuple.rb'
+require_relative 'taxon/list.rb'
+require_relative 'taxon/record.rb'
+require_relative 'taxon/constraints.rb'
+require_relative 'taxon/table.rb'
+require_relative 'taxon/index.rb'
+require_relative 'taxon/entity.rb'
+require_relative 'taxon/union.rb'
+
+module Taxon
+  include Primitives, Tuple, Union, List, Record, Table, Constraints, Entity
+  extend self
+end

data/lib/taxon/constraints.rb

@@ -0,0 +1,18 @@
+module Constraints
+
+  def bounded?(data, min=nil, max=nil)
+    if ((min==nil)&&(max==nil))
+      true
+    elsif (min==nil)
+      data <= max
+    elsif (max==nil)
+      data >= min
+    else
+      (data <= max) && (data >= min)
+    end
+  end
+
+  def upper_bounded?(data, max=nil)
+    max==nil ? true : data <= max
+  end
+end

data/lib/taxon/entity.rb

@@ -0,0 +1,38 @@
+require_relative 'primitives.rb'
+require_relative 'tuple.rb'
+require_relative 'record.rb'
+require_relative 'guard.rb'
+
+module Entity
+
+  module DefaultEntities
+    include Primitives, Record, Tuple
+    extend self
+  end
+
+  def entity?(data, pred, ns=DefaultEntities)
+    Taxon::Guard.predicate?(ns, pred) ? ns.send(pred, data) : false
+  end
+
+  def entity(data, ns=DefaultEntities)
+    to_entity_name entity_tests(ns).find{|i| ns.send(i, data)}
+  end
+
+  def entity_tests(ns=DefaultEntities)
+    entity_format_methods(ns).map{|m| m.intern}
+  end
+
+  def entity_format_methods(ns)
+    ns.public_instance_methods.select{|m| m.to_s.end_with?("?")}
+  end
+
+  def to_entity_name(method_name)
+    if (method_name.is_a?(Symbol) || method_name.is_a?(String))
+      method_name.to_s.split("_").map{|i| to_entity_word(i)}.join
+    end
+  end
+
+  def to_entity_word(word)
+    word.end_with?("?") ? word.gsub(/\?/, "").capitalize : word.capitalize
+  end
+end

data/lib/taxon/guard.rb

@@ -0,0 +1,33 @@
+module Taxon
+  module Guard
+    extend self
+
+    def predicate?(rec, meth)
+      meth.is_a?(Symbol) && rec.respond_to?(meth)
+    end
+
+    def predicates?(rec, meths)
+      meths.is_a?(Array) && meths.all?{|m| predicate?(rec, m)}
+    end
+
+    def varying_predicates?(rec, meths)
+      predicate?(rec, meths) || predicates?(rec, meths)
+    end
+
+    def record_key?(data)
+      data.is_a?(Symbol) || data.is_a?(String)
+    end
+
+    def record_keys?(data)
+      data.is_a?(Array) && data.all?{|i| record_key?(i)}
+    end
+
+    def record_target?(rec, data)
+      any_record?(data) && Guard.predicates?(rec, data.values)
+    end
+
+    def any_record?(data)
+      data.is_a?(Hash) && data.keys.all?{|i| record_key?(i)}
+    end
+  end
+end

data/lib/taxon/index.rb

@@ -0,0 +1,59 @@
+require_relative 'record.rb'
+
+# An array of records with set semantics
+module Taxon
+  module Index
+    include Record
+
+    def index(preds)
+      ind = Array.new
+      setup_index_keys(ind, preds)
+      setup_index_targets(ind, preds)
+      ind
+    end
+
+    def setup_index_keys(index, preds)
+      if Guard.record_keys?(preds)
+        index.define_singleton_method(:index_keys) {preds}
+      elsif Guard.record_target?(self, preds)
+        index.define_singleton_method(:index_keys) {preds.keys}
+      end
+    end
+
+    def setup_index_targets(index, targets)
+      if Guard.record_keys?(targets)
+        index.define_singleton_method(:index_targets) {}
+      elsif Guard.record_target?(self, targets)
+        index.define_singleton_method(:index_targets) {targets}
+      end
+    end
+
+    def index?(data)
+      data.is_a?(Array) &&
+        data.respond_to?(:index_keys) &&
+          data.respond_to?(:index_targets)
+    end
+
+    def add(index, record, ignore=ignore_keys)
+      if nothing?(index.index_targets)
+        unique_insert(index, record, ignore) if record?(record, index.index_keys)
+      else
+        unique_insert(index, record, ignore) if record?(record, index.index_targets)
+      end
+    end
+
+    def unique_insert(index, record, ignore=ignore_keys)
+      index.all?{|e| is_unique_entry(e, record, ignore)} ? index.push(record) : index
+    end
+
+    def is_unique_entry(entry, record, ignore=ignore_keys)
+      keys = (entry.keys - ignore).any?{|i| entry[i] != record[i]}
+    end
+
+    def ignore_keys
+      [:uuid, :UUID, :id, :Id, :ID]
+    end
+
+    extend self
+  end
+end

data/lib/taxon/list.rb

@@ -0,0 +1,60 @@
+require_relative 'tuple.rb'
+require_relative 'primitives.rb'
+require_relative 'guard.rb'
+
+module List
+  include Tuple, Primitives
+  extend self
+
+  def has_matching_elements(seq)
+    type = seq[0].class
+    seq.all?{|i| i.is_a?(type)}
+  end
+
+  def any_list?(seq)
+    any_tuple?(seq) && has_matching_elements(seq)
+  end
+
+  def list?(seq, pred=nil)
+    if any_tuple?(seq)
+      Taxon::Guard.predicate?(self, pred) ? seq.all?{|i| send(pred, i)} : any_list?(seq)
+    else
+      false
+    end
+  end
+
+  def list(data, pred)
+    if varying?(data, pred)
+      send(pred, data) ? [data] : data
+    else
+      []
+    end
+  end
+
+  def varying?(data, pred)
+    if Taxon::Guard.predicate?(self, pred)
+      def multiple?(data, pred)
+        list?(data, pred)
+      end
+      send(pred, data) || send(:multiple?, data, pred)
+    else
+      false
+    end
+  end
+
+  def symbols?(data)
+    list?(data, :symbol?)
+  end
+
+  def numbers?(data)
+    list?(data, :number?)
+  end
+
+  def strings?(data)
+    list?(data, :string?)
+  end
+
+  def nothings?(data)
+    list?(data, :nothing?)
+  end
+end

data/lib/taxon/primitives.rb

@@ -0,0 +1,22 @@
+module Primitives
+
+  def nothing?(data)
+    data == nil
+  end
+
+  def number?(data)
+    data.is_a? Numeric
+  end
+
+  def string?(data)
+    data.is_a? String
+  end
+
+  def symbol?(data)
+    data.is_a? Symbol
+  end
+
+  def boolean?(data)
+    data.is_a?(TrueClass) || data.is_a?(FalseClass)
+  end
+end

data/lib/taxon/record.rb

@@ -0,0 +1,23 @@
+require_relative 'primitives.rb'
+require_relative 'guard.rb'
+
+module Record
+  include Primitives
+
+  def any_record?(data)
+    Taxon::Guard.any_record?(data)
+  end
+
+  def record?(data, pred=nil)
+    if Taxon::Guard.record_key?(pred)
+      any_record?(data) && data.has_key?(pred)
+    elsif Taxon::Guard.record_keys?(pred)
+      any_record?(data) && pred.all?{|i| data.has_key?(i)}
+    elsif Taxon::Guard.record_target?(self, pred)
+      data.is_a?(Hash) &&
+        pred.entries.all?{|k, v| data.has_key?(k) && send(v, data[k])}
+    else
+      any_record?(data)
+    end
+  end
+end

data/lib/taxon/registry.rb

@@ -0,0 +1,13 @@
+module Registry
+  extend self
+
+  @@entities = []
+
+  def register(entity_name, basic_entity, predicate)
+    
+  end
+
+  def self.entities
+    @@entities
+  end
+end

data/lib/taxon/table.rb

@@ -0,0 +1,16 @@
+require_relative 'tuple.rb'
+require_relative 'record.rb'
+
+module Table
+  include Tuple, Record
+
+  def tabular?(data)
+    any_tuple?(data) &&
+      data.all?{|i| any_record?(i)}
+  end
+
+  def table?(data, pred=nil)
+    any_tuple?(data) &&
+      data.all?{|i| record?(i, pred)}
+  end
+end

data/lib/taxon/tuple.rb

@@ -0,0 +1,25 @@
+require_relative 'guard.rb'
+
+module Tuple
+
+  def empty_tuple?(seq)
+    any_tuple?(seq) && seq.empty?
+  end
+
+  def any_tuple?(seq)
+    seq.is_a?(Array)
+  end
+
+  def tuple?(tuple, entry_tests=[])
+    if empty_tuple?(entry_tests)
+      any_tuple?(tuple)
+    elsif Taxon::Guard.varying_predicates?(self, entry_tests)
+      if entry_tests.is_a? Array
+        upper = [tuple.size, entry_tests.size].min
+        (0...upper).all?{|i| send(entry_tests[i], tuple[i])}
+      else
+        send(entry_tests, tuple[0])
+      end
+    end
+  end
+end

data/lib/taxon/union.rb

@@ -0,0 +1,24 @@
+require_relative 'primitives.rb'
+require_relative 'guard.rb'
+
+module Taxon
+  module Union
+    include Primitives
+
+    def any?(data)
+      data.is_a? Object
+    end
+
+    def union?(data, pred=:any?)
+      if Taxon::Guard.varying_predicates?(self, pred)
+        if Taxon::Guard.predicate?(self, pred)
+          send(pred, data)
+        else
+          pred.any?{|i| send(i, data)}
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/taxon/version.rb

@@ -0,0 +1,3 @@
+module Taxon
+  VERSION = "0.9.0"
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: taxon.benforeva
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Andre Dickson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-24 00:00:00.000000000 Z
+dependencies: []
+description: Taxon lets you write class-free Ruby programs that are extremely explicit
+  about the entities they operate on.
+email: taxon@andredickson.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/taxon.rb
+- lib/taxon/constraints.rb
+- lib/taxon/entity.rb
+- lib/taxon/guard.rb
+- lib/taxon/index.rb
+- lib/taxon/list.rb
+- lib/taxon/primitives.rb
+- lib/taxon/record.rb
+- lib/taxon/registry.rb
+- lib/taxon/table.rb
+- lib/taxon/tuple.rb
+- lib/taxon/union.rb
+- lib/taxon/version.rb
+homepage: https://bitbucket.org/benforeva/taxon/src/master/
+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.14.1
+signing_key: 
+specification_version: 4
+summary: class-free programming for Ruby
+test_files: []