Module: Dalton::Utility

Defined in:
lib/dalton/utility.rb

Class Method Summary collapse

Class Method Details

.clojure_equal?(one, other) ⇒ Boolean

Returns:

  • (Boolean) 


43
44
45
 
# File 'lib/dalton/utility.rb', line 43

def clojure_equal?(one, other)
  run_clojure_function('clojure.core/=', one, other)
end

.gensym(s) ⇒ Object 



56
57
58
 
# File 'lib/dalton/utility.rb', line 56

def gensym(s)
  run_clojure_function('clojure.core/gensym', sym(s))
end

.kw(k) ⇒ Object 



68
69
70
71
72
 
# File 'lib/dalton/utility.rb', line 68

def kw(k)
  k = k.to_s if k.is_a? Symbol
  k = k[1..-1] if k.start_with? ':'
  Java::ClojureLang::Keyword.intern(k)
end

.list(*items) ⇒ Object 



74
75
76
 
# File 'lib/dalton/utility.rb', line 74

def list(*items)
  Dalton::Utility.run_clojure_function("clojure.core/list*", items)
end

.meta(value) ⇒ Object 



82
83
84
 
# File 'lib/dalton/utility.rb', line 82

def meta(value)
  Dalton::Utility.run_clojure_function("clojure.core/meta", value)
end

.read_edn(edn) ⇒ Object 



30
31
32
33
34
35
36
37
 
# File 'lib/dalton/utility.rb', line 30

def read_edn(edn)
  readers = PersistentArrayMap.create({Keyword.intern('readers') => PersistentArrayMap.create({
      Java::ClojureLang::Symbol.intern('db/fn') => RT.var('datomic.function', 'construct'),
      Java::ClojureLang::Symbol.intern('db/id') => RT.var('datomic.db', 'id-literal')
  })})

  run_clojure_function("clojure.edn/read-string", readers, edn)
end

.require_clojure(namespace) ⇒ Object 



22
23
24
25
 
# File 'lib/dalton/utility.rb', line 22

def require_clojure(namespace)
  require_function = RT.var("clojure.core", "require").fn
  require_function.invoke(Java::ClojureLang::Symbol.intern(namespace))
end

.rubify_edn(edn) ⇒ Object 



39
40
41
 
# File 'lib/dalton/utility.rb', line 39

def rubify_edn(edn)
  Translation.from_clj(read_edn(edn))
end

.run_clojure_function(namespaced_function, *arguments) ⇒ Object 



10
11
12
13
14
15
 
# File 'lib/dalton/utility.rb', line 10

def run_clojure_function(namespaced_function, *arguments)
  namespace, function_name = namespaced_function.to_s.split('/', 2)
  namespace && function_name or
    raise ArgumentError, "Namespaced function required. Got: #{namespaced_function.inspect}"
  RT.var(namespace, function_name).fn.invoke(*arguments)
end

.run_database_function(db, function_ident, *arguments) ⇒ Object 



17
18
19
20
 
# File 'lib/dalton/utility.rb', line 17

def run_database_function(db, function_ident, *arguments)
  function_entity = db.entity(Translation.from_ruby(function_ident))
  function_entity.fn.invoke(*arguments)
end

.sym(s) ⇒ Object 



51
52
53
54
 
# File 'lib/dalton/utility.rb', line 51

def sym(s)
  s = s.to_s if s.is_a? Symbol
  Java::ClojureLang::Symbol.intern(s)
end

.tag(value, tag) ⇒ Object 



86
87
88
 
# File 'lib/dalton/utility.rb', line 86

def tag(value, tag)
  with_meta(value, Dalton::Translation.from_ruby(tag: tag))
end

.tempid(partition) ⇒ Object 



60
61
62
 
# File 'lib/dalton/utility.rb', line 60

def tempid(partition)
  Peer.tempid(kw(partition))
end

.to_edn(clojure_data) ⇒ Object 



47
48
49
 
# File 'lib/dalton/utility.rb', line 47

def to_edn(clojure_data)
  run_clojure_function('clojure.core/pr-str', clojure_data)
end

.with_meta(value, meta) ⇒ Object 



78
79
80
 
# File 'lib/dalton/utility.rb', line 78

def with_meta(value, meta)
  Dalton::Utility.run_clojure_function("clojure.core/with-meta", value, meta)
end