rie 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f20eb6f5e275de66f7eecb8776d6b050d778fd0
+  data.tar.gz: 26672d08cfeee732ea10de1d5ac688ded3b92ff0
+SHA512:
+  metadata.gz: 8cb9a6c21a61de5238cf33b34a5719d343d2ee229799c02acc017349d184dec8ed5f2002c2f8e50b428f2d9686db34a9757e656d0ce00b88e75519c65e40d151
+  data.tar.gz: e89b60722ac59e0b22587d1dab000a2027eae8a0fc71deb62ddec855aa7700675d5b746b781d8ca3ecd1afaf2ea5fa0c8642d1ba7fa075421585edc5d800e3d2

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'minitest'
+gem 'wrong'
+
+gem 'jbundler'
+gem 'dalton'

data/lib/rie.rb

@@ -0,0 +1,10 @@
+require 'logger' # stdlib
+require 'dalton'
+
+load_dir = Pathname.new(__FILE__).dirname
+load load_dir.join('rie/model.rb')
+load load_dir.join('rie/schema.rb')
+load load_dir.join('rie/attribute.rb')
+load load_dir.join('rie/base_finder.rb')
+load load_dir.join('rie/base_changer.rb')
+load load_dir.join('rie/validator.rb')

data/lib/rie/attribute.rb

@@ -0,0 +1,149 @@
+module Rie
+  class Attribute
+    attr_reader :name, :model, :datomic_attribute, :type
+    def initialize(model, name, opts={})
+      @name = name
+      @model = model
+      @datomic_attribute = opts.fetch(:datomic_attribute) { default_datomic_attribute }
+      @type = Type.for(opts[:type])
+    end
+
+    def default_datomic_attribute
+      "#{model.namespace}.#{model.datomic_name}/#{name.to_s.tr('_', '-')}"
+    end
+
+    def load(value)
+      type.load(self, value)
+    end
+
+    def dump(value)
+      type.dump(self, value)
+    end
+
+    def datoms_for(changer, value, &b)
+      type.datoms_for(self, changer, value, &b)
+    end
+
+    class Type
+      def self.for(definition)
+        return definition if definition.is_a? Type
+        return AutoType.new if definition.nil?
+
+        type, *args = definition
+        type_name = "#{type.capitalize}Type"
+        raise "no such type #{type}" unless const_defined?(type_name)
+        const_get(type_name).new(*args)
+      end
+
+      def load(attr, value)
+        value
+      end
+
+      def dump(attr, value)
+        value
+      end
+
+      def datoms_for(attr, changer, value, &b)
+        yield(:'db/id' => changer.id, attr.datomic_attribute => dump(attr, value))
+      end
+
+      def invalid_value!(attr, value)
+        raise ::TypeError, "invalid value for #{attr.datomic_attribute}: #{value.inspect}"
+      end
+
+      class Scalar < Type
+        def inspect
+          "(scalar)"
+        end
+      end
+
+      class AutoType < Type
+        def type_from_value(value)
+          case value
+          when Enumerable
+            SetType.new(self)
+          when Dalton::Entity
+            RefType.new(raise 'TODO')
+          when Numeric, String, Symbol, true, false, nil
+            Scalar.new
+          else
+            raise TypeError.new("unknown value type: #{value.inspect}")
+          end
+        end
+
+        def load(attr, value)
+          type_from_value(value).load(attr, value)
+        end
+
+        def dump(attr, value)
+          type_from_value(value).dump(attr, value)
+        end
+
+        def datoms_for(attr, changer, value, &b)
+          type_from_value(value).datoms_for(attr, changer, value, &b)
+        end
+
+        def inspect
+          "(auto)"
+        end
+      end
+
+      class RefType < Type
+        attr_reader :ref_class
+        def initialize(ref_class)
+          @ref_class = ref_class
+        end
+
+        def inspect
+          "(ref #{@ref_class.name})"
+        end
+
+        def load(attr, entity_map)
+          return nil if entity_map.nil?
+          registry_name = entity_map.get(attr.model.datomic_type_key)
+          invalid_value!(attr, entity_map) unless registry_name == @ref_class.datomic_type
+          @ref_class.new(entity_map)
+        end
+
+        def dump(attr, value)
+          value.id
+        end
+
+        def datoms_for(attr, changer, value, &block)
+          invalid_value!(attr, value) unless value.respond_to? :id
+
+          yield(:'db/id' => changer.id, attr.datomic_attribute => value.id)
+
+          value.generate_datoms(&block) if value.is_a? BaseChanger
+        end
+      end
+
+      class SetType < Type
+        def initialize(element_type)
+          @element_type = Type.for(element_type)
+        end
+
+        def inspect
+          "(set #{@element_type.inspect})"
+        end
+
+        def dump(attr, value)
+          value.map { |x| @element_type.dump(value) }
+        end
+
+        def load(attr, value)
+          # empty sets are often returned as nil in datomic :[
+          return Set.new if value.nil?
+          invalid_value!(attr, value) unless value.is_a? Enumerable
+          Set.new(value.map { |e| @element_type.load(attr, e) })
+        end
+
+        def datoms_for(attr, changer, value, &block)
+          value.each do |v|
+            @element_type.datoms_for(attr, changer, v, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rie/base_changer.rb

@@ -0,0 +1,93 @@
+module Rie
+  class BaseChanger
+    attr_reader :id, :original, :changes, :retractions
+    def initialize(id, attrs)
+      @id = id
+      @original = attrs.dup.freeze
+      @changes = {}
+      @retractions = Set.new
+    end
+
+    def retract!(attribute)
+      @retractions << attribute
+    end
+
+    def change(key=nil, &b)
+      b.call(self)
+      self
+    end
+
+    def change_ref(key, &b)
+      attribute = model.get_attribute(key)
+      type = attribute.type
+
+      unless type.respond_to? :ref_class
+        raise ::TypeError, "change_ref only works on refs - #{key} is a #{type.inspect} is not a ref"
+      end
+
+      self[key] = self[key] ? self[key].change(&b) : type.ref_class.create(&b)
+    end
+
+    def change!(&b)
+      change(&b)
+      save!
+    end
+
+    def [](key)
+      return nil if @retractions.include? key
+      @changes.fetch(key) { @original[key] }
+    end
+
+    def original(key)
+      @original[key]
+    end
+
+    def change_in(key)
+      [original(key), self[key]]
+    end
+
+    def []=(key, val)
+      if val.nil?
+        @retractions << key
+      else
+        @retractions.delete(key)
+        @changes[key] = val
+      end
+    end
+
+    def updated_attributes
+      out = model.attributes.merge(@changes)
+      @retractions.each { |r| out.delete(r) }
+      out
+    end
+
+    def generate_datoms(&b)
+      return enum_for(:generate_datoms).to_a unless block_given?
+
+      yield model.base_attributes.merge(:'db/id' => @id)
+      @changes.each do |key, new_val|
+        attribute = model.get_attribute(key)
+        attribute.datoms_for(self, new_val, &b)
+      end
+    end
+
+  private
+    def save!
+      validate!
+      persist!
+    end
+
+    def persist!
+      result = model.transact(generate_datoms)
+      @id = result.resolve_tempid(@id) unless @id.is_a? Fixnum
+      model.new(result.db_after.entity(@id))
+    rescue Dalton::TypeError, Dalton::UniqueConflict => e
+      raise TransactionValidationError.new(self, e)
+    end
+
+    def validate!
+      model.validator.run_all!(self)
+    end
+  end
+end
+

data/lib/rie/base_finder.rb

@@ -0,0 +1,99 @@
+module Rie
+  class NotFound < StandardError
+    attr_reader :model, :id
+    def initialize(model, id)
+      @model = model
+      @id = id
+    end
+
+    def message
+      "Could not find #{model} with id #{id}"
+    end
+  end
+
+  class BaseFinder
+    include Enumerable
+    include Dalton::Utility
+
+    # should be overridden automatically
+    def model
+      raise "abstract"
+    end
+
+    def inspect
+      translated = Dalton::Translation.from_ruby(all_constraints).to_edn[1..-2]
+      "#<#{self.class.name} ##{db.basis_t} :where #{translated}>"
+    end
+
+    attr_reader :db, :constraints
+    def initialize(db, constraints=[])
+      @db = db
+      @constraints = constraints
+    end
+
+    def where(*constraints)
+      new_constraints = @constraints.dup
+      constraints.each do |c|
+        case c
+        when Array
+          new_constraints << c
+        when Hash
+          interpret_constraints(c, &new_constraints.method(:<<))
+        end
+      end
+
+      self.class.new(@db, new_constraints)
+    end
+
+    def entity(id)
+      entity = @db.entity(id)
+
+      unless entity.get(model.datomic_type_key) == model.datomic_type
+        raise NotFound.new(model, id)
+      end
+
+      model.new(entity)
+    end
+
+    def results
+      query = [:find, sym('?e'), :in, sym('$'), :where, *all_constraints]
+      q(query).lazy.map do |el|
+        model.new(@db.entity(el.first))
+      end
+    end
+
+    def type_constraint
+      [sym('?e'), model.datomic_type_key, model.datomic_type]
+    end
+
+    def all_constraints
+      [type_constraint, *constraints]
+    end
+
+    def each(&b)
+      results.each(&b)
+    end
+
+    def with_model(model)
+      model.finder(@db)
+    end
+
+  private
+
+    def interpret_constraints(hash, &b)
+      return enum_for(:interpret_constraints, hash) unless block_given?
+
+      hash.each do |key, value|
+        attribute = model.get_attribute(key)
+        yield [sym('?e'), attribute.datomic_attribute, attribute.dump(value)]
+      end
+    end
+
+    def q(query)
+      translated_query = Dalton::Translation.from_ruby(query)
+      Model.logger.info("datomic.q #{translated_query.to_edn}")
+      result = @db.q(translated_query)
+      Dalton::Translation.from_clj(result)
+    end
+  end
+end

data/lib/rie/has_database.rb

@@ -0,0 +1,21 @@
+module Rie
+  module HasDatabase
+    attr_accessor :db
+
+    def datomic_uri
+      raise "please define datomic_uri on #{self.class.name}"
+    end
+
+    def datomic_connection
+      Dalton::Connection.connect(datomic_uri)
+    end
+
+    def refresh_datomic!
+      @db = datomic_connection.db
+    end
+
+    def find(model, *args)
+      model.finder(@db, *args)
+    end
+  end
+end

data/lib/rie/model.rb

@@ -0,0 +1,225 @@
+module Rie
+  module Model
+    def self.included(base)
+      base.class_eval do
+        @attributes = {}
+        @base_attributes = {}
+        @defaults = {}
+        @validator = Validator.new(base)
+
+        const_set :Finder, Class.new(BaseFinder) {
+          # we use a constant here so that `super` works
+          # in overriding generated methods
+          const_set :AttributeMethods, Module.new
+          include self::AttributeMethods
+          define_method(:model) { base }
+        }
+
+        const_set :Changer, Class.new(BaseChanger) {
+          # as above
+          const_set :AttributeMethods, Module.new
+          include self::AttributeMethods
+          define_method(:model) { base }
+        }
+
+        extend Rie::Model::ClassMethods
+      end
+    end
+
+    @registry = {}
+    @logger = Logger.new($stderr)
+    @logger.level = Logger::WARN
+
+    class << self
+      attr_reader :registry
+      attr_writer :logger
+
+      def install_schemas!
+        registry.values.each(&:install_schema!)
+      end
+
+      def install_bases!
+        registry.values.each(&:install_base!)
+      end
+
+      def install!
+        install_bases!
+        install_schemas!
+      end
+
+      attr_accessor :namespace, :partition, :uri, :logger
+      def configure(&b)
+        yield self
+      end
+    end
+
+    module ClassMethods
+      attr_reader :attributes
+      attr_reader :defaults
+      attr_reader :validator
+      attr_reader :datomic_name
+      attr_reader :namespace
+      attr_reader :partition
+      attr_reader :base_attributes
+
+      def transact(edn)
+        Model.logger.info("datomic.transact #{Dalton::Connection.convert_datoms(edn).to_edn}")
+        connection.transact(edn)
+      end
+
+      def base_attribute(key, val)
+        @base_attributes.merge!(key => val)
+      end
+
+      def uri(arg=nil)
+        @uri = arg if arg
+        @uri or Model.uri or raise "you must specify a datomic uri for #{self}"
+      end
+
+      def connection
+        Dalton::Connection.connect(uri)
+      end
+
+      def datomic_type
+        :"#{namespace}.type/#{datomic_name}"
+      end
+
+      def datomic_type_key
+        :"#{namespace}/type"
+      end
+
+      def attribute(attr, datomic_key=nil, opts={})
+        if datomic_key.is_a? Hash
+          opts = datomic_key
+          datomic_key = nil
+        end
+
+        datomic_key ||= "#{self.namespace}.#{self.datomic_name}/#{attr.to_s.tr('_', '-')}"
+        define_attribute(attr, datomic_key, opts)
+      end
+
+      def define_attribute(key, datomic_key, opts={})
+        @attributes[key] = Attribute.new(self, key, opts.merge(datomic_attribute: datomic_key))
+        @defaults[key] = opts[:default]
+
+        define_method(key) { self[key] }
+
+        self::Finder::AttributeMethods.class_eval do
+          define_method("by_#{key}") { |v| where(key => v) }
+        end
+
+        self::Changer::AttributeMethods.class_eval do
+          define_method(key) { self[key] }
+          define_method("#{key}=") { |v| self[key] = v }
+        end
+      end
+
+      def get_attribute(key)
+        @attributes.fetch(key) do
+          raise ArgumentError, "Undefined attribute #{key} for #{self}"
+        end
+      end
+
+      def finders(&b)
+        self::Finder.class_eval(&b)
+      end
+
+      def changers(&b)
+        self::Changer.class_eval(&b)
+      end
+
+      def validation(&b)
+        @validator.specify(&b)
+      end
+
+      def finder(db, constraints=[])
+        self::Finder.new(db).where(constraints)
+      end
+
+      def create!(&b)
+        self::Changer.new(Dalton::Utility.tempid(partition), defaults).change!(&b)
+      end
+
+      def create(&b)
+        self::Changer.new(Dalton::Utility.tempid(partition), defaults).change(&b)
+      end
+    end
+
+    attr_reader :finder, :entity
+    def initialize(entity)
+      @entity = entity
+      @finder = self.class::Finder.new(entity.db)
+    end
+
+    def id
+      entity.get(:'db/id')
+    end
+
+    def db
+      entity.db
+    end
+
+    def at(db)
+      self.class::Finder.new(db).entity(self.id)
+    end
+
+    def [](key)
+      definition = self.class.get_attribute(key)
+
+      definition.load(entity.get(definition.datomic_attribute))
+    end
+
+    def interpret_value(value)
+      case value
+      when Enumerable
+        value.lazy.map { |e| interpret_value(e) }
+      when Java::DatomicQuery::EntityMap
+        self.class.interpret_entity(value)
+      when Numeric, String, Symbol, true, false, nil
+        value
+      else
+        raise TypeError.new("unknown value type: #{value.inspect}")
+      end
+    end
+
+    def attributes
+      out = {}
+
+      self.class.attributes.each do |attr, _|
+        out[attr] = send(attr)
+      end
+
+      out
+    end
+
+    def to_h
+      attributes.merge(:id => id)
+    end
+
+    # TODO: fix this implementation
+    def updated_at
+      txid = db.q('[:find (max ?t) :in $ ?e :where [?e _ _ ?t]]', self.id).first.first
+      db.entity(txid).get(:'db/txInstant').to_time
+    end
+
+    def changer
+      self.class::Changer.new(id, attributes)
+    end
+
+    def change(&b)
+      changer.change(&b)
+    end
+
+    def change!(&b)
+      changer.change!(&b)
+    end
+
+    def retract!
+      self.class.transact([[:'db.fn/retractEntity', self.id]])
+    end
+
+    def ==(other)
+      self.entity == other.entity
+    end
+  end
+end

data/lib/rie/schema.rb

@@ -0,0 +1,112 @@
+module Rie
+  module Model
+    module ClassMethods
+      def schema(name=nil, opts={}, &b)
+        return @schema unless block_given?
+
+        if name.is_a? Hash
+          opts = name
+          name = nil
+        end
+
+        @datomic_name = name
+        @datomic_name ||= self.name
+          .gsub(/[^[:alpha:]]+/, '-')
+          .gsub(/(?<=[[:lower:]])(?=[[:upper:]])/, '-')
+          .downcase
+
+        @namespace = opts.fetch(:namespace) { Model.namespace } \
+          or raise ArgumentError.new("no namespace configured for #{self} or globally")
+        @partition = opts.fetch(:partition) { Model.partition } \
+          or raise ArgumentError.new("no partition configured for #{self} or globally")
+        @partition = :"db.part/#{partition}" unless partition.to_s.start_with?('db.part/')
+
+        Model.registry[datomic_type.to_s] = self
+        base_attribute datomic_type_key, datomic_type
+
+        @schema = Schema.new(self, &b)
+      end
+
+      def install_schema!
+        raise ArgumentError.new("no schema defined for #{self}!") unless schema
+        schema.install!
+      end
+
+      def install_base!
+        transact <<-EDN
+          [{:db/id #db/id[:db.part/db]
+            :db/ident :#{partition}
+            :db.install/_partition :db.part/db}
+
+           {:db/id #db/id[:db.part/db]
+            :db/ident :#{namespace}/type
+            :db/valueType :db.type/ref
+            :db/cardinality :db.cardinality/one
+            :db/doc "A model's type"
+            :db.install/_attribute :db.part/db}]
+        EDN
+      end
+    end
+  end
+
+  class Schema
+    include Dalton::Utility
+
+    attr_reader :model, :transactions
+    def initialize(model, &block)
+      @model = model
+      @transactions = []
+      declare_type
+      instance_exec(&block)
+    end
+
+    def name
+      model.datomic_name
+    end
+
+    def partition
+      model.partition
+    end
+
+    def namespace
+      model.namespace
+    end
+
+    def key(key, subkey=nil)
+      if subkey
+        :"#{namespace}.#{key}/#{subkey}"
+      else
+        :"#{namespace}/#{key}"
+      end
+    end
+
+    def declare_type
+      edn [:'db/add', Peer.tempid(kw(partition)), :'db/ident', key(:type, name)]
+    end
+
+    def edn(edn)
+      @transactions << edn
+    end
+
+    def attribute(attr_key, opts={})
+      config = {
+        :'db/id' => opts.fetch(:id) { Peer.tempid(kw('db.part/db')) },
+        :'db/ident' => kw(opts.fetch(:ident) { key(model.datomic_name, attr_key) }),
+        :'db/valueType' => :"db.type/#{opts.fetch(:value_type)}",
+        :'db/cardinality' => :"db.cardinality/#{opts.fetch(:cardinality, :one)}",
+        :'db/doc' => opts.fetch(:doc) { "The #{attr_key} attribute" },
+        :'db.install/_attribute' => :'db.part/db',
+      }
+
+      config[:'db/unique'] = :"db.unique/#{opts[:unique]}" if opts[:unique]
+
+      edn(config)
+    end
+
+    def install!
+      transactions.each do |t|
+        model.transact([t])
+      end
+    end
+  end
+end

data/lib/rie/validator.rb

@@ -0,0 +1,105 @@
+module Rie
+  class ValidationError < StandardError
+    attr_reader :changes, :errors
+
+    def initialize(changes, errors)
+      @changes = changes
+      @errors = errors
+    end
+
+    def errors_on(key, &b)
+      return enum_for(:errors_on, key).to_a unless block_given?
+
+      errors.each do |(keys, message)|
+        yield message if keys.include? key
+      end
+    end
+
+    def errors_on?(key)
+      errors_on(key).any?
+    end
+  end
+
+  class TransactionValidationError < ValidationError
+    def initialize(changes, datomic_error)
+      @changes = changes
+      @datomic_error = datomic_error
+    end
+
+    def errors
+      # TODO: translate this key
+      [@datomic_error.attribute, @datomic_error.message]
+    end
+
+    def errors_on?(key)
+      changes.model.get_attribute(key).datomic_attribute == @datomic_error.attribute
+    end
+  end
+
+  class Validator
+    # a definition of a validator.  the block gets run in the context of
+    # a Scope, and may call `invalid!` with optional attributes and an
+    # error message
+    class Rule
+      class Scope
+        def initialize(attrs, validate, &report)
+          @validate = validate
+          @attrs = attrs
+          @report = report
+        end
+
+        def invalid!(attr_names=nil, description)
+          attr_names ||= @attrs
+          attr_names = Array(attr_names)
+
+          @report.call [attr_names, description]
+        end
+
+        def run(values)
+          instance_exec(*values, &@validate)
+        end
+      end
+
+      def initialize(*attrs, &block)
+        @attrs = attrs
+        @block = block
+      end
+
+      def run(changer, &out)
+        values = @attrs.map { |a| changer.send(a) }
+        Scope.new(@attrs, @block, &out).run(values)
+      end
+    end
+
+    attr_reader :validators
+    def initialize(model, &defn)
+      @model = model
+      @validators = []
+      specify(&defn) if defn
+    end
+
+    def specify(&defn)
+      instance_eval(&defn)
+    end
+
+    # define a validation on *attrs using &block.
+    # See Rule
+    def validate(*attrs, &block)
+      validators << Rule.new(*attrs, &block)
+    end
+
+    # returns an enumerable of validation errors on the changeset,
+    # which is empty if the changeset is valid
+    def run_all(changer, &report)
+      return enum_for(:run_all, changer).to_a unless block_given?
+
+      validators.each { |v| v.run(changer, &report) }
+    end
+
+    # raises a ValidationError if the changeset is invalid
+    def run_all!(changer)
+      errors = run_all(changer)
+      raise ValidationError.new(changer, errors) if errors.any?
+    end
+  end
+end

data/lib/rie/version.rb

@@ -0,0 +1,5 @@
+module Rie
+  def self.version
+    '0.0.2'
+  end
+end

data/rie.gemspec

@@ -0,0 +1,20 @@
+require './lib/rie/version'
+
+Gem::Specification.new do |s|
+  s.name = "rie"
+  s.version = Rie.version
+  s.authors = ["Jeanine Adkisson"]
+  s.email = ["jneen@goodguide.com"]
+  s.summary = "A modeling library for datomic"
+
+  s.description = <<-desc.strip.gsub(/\s+/, ' ')
+    Immutable models, first-class changesets, value-based programming
+  desc
+
+  # s.add_dependency 'dalton'
+
+  s.homepage = "https://github.com/GoodGuide/rie"
+  s.rubyforge_project = "rie"
+  s.files = Dir['README.md', 'Gemfile', 'LICENSE', 'rie.gemspec', 'lib/**/*.rb']
+  s.license = 'EPL'
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: rie
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jeanine Adkisson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-06-02 00:00:00.000000000 Z
+dependencies: []
+description: Immutable models, first-class changesets, value-based programming
+email:
+- jneen@goodguide.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- rie.gemspec
+- lib/rie.rb
+- lib/rie/schema.rb
+- lib/rie/base_changer.rb
+- lib/rie/validator.rb
+- lib/rie/attribute.rb
+- lib/rie/has_database.rb
+- lib/rie/model.rb
+- lib/rie/version.rb
+- lib/rie/base_finder.rb
+homepage: https://github.com/GoodGuide/rie
+licenses:
+- EPL
+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: rie
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: A modeling library for datomic
+test_files: []
+has_rdoc: