diametric 0.1.1-java

data/lib/diametric/query.rb

@@ -0,0 +1,259 @@
+require 'diametric'
+
+module Diametric
+  # +Query+ objects are used to generate Datomic queries, whether to
+  # send via an external client or via the persistence API. The two
+  # methods used to generate a query are +.where+ and +.filter+, both
+  # of which are chainable. To get the query data and arguments for a
+  # +Query+, use the +data+ method.
+  #
+  # If you are using a persistence API, you can ask +Query+ to get the
+  # results of a Datomic query. +Diametric::Query+ is an
+  # +Enumerable+. To get the results of a query, use +Enumerable+
+  # methods such as +.each+ or +.first+. +Query+ also provides a
+  # +.all+ method to run the query and get the results.
+  class Query
+    include Enumerable
+
+    attr_reader :conditions, :filters, :filter_attrs, :model, :connection, :resolve
+
+    # Create a new Datomic query.
+    #
+    # @param model [Entity] This model must include +Datomic::Entity+. Including
+    #   a persistence module is optional.
+    def initialize(model, connection_or_database=nil, resolve=false)
+      @model = model
+      @conditions = {}
+      @filters = []
+      @filter_attrs = []
+      @conn_or_db = connection_or_database
+      @resolve = resolve
+    end
+
+    # Add conditions to your Datomic query. Conditions check for equality
+    # against entity attributes. In addition, you can add conditions for
+    # use as variables in filters.
+    #
+    # @example Looking for mice named Wilbur.
+    #   Query.new(Mouse).conditions(:name => "Wilbur")
+    #
+    # @param conditions [Hash] Datomic variables and values.
+    # @return [Query]
+    def where(conditions)
+      query = self.dup
+      query.conditions = query.conditions.merge(conditions)
+      query
+    end
+
+    # Add a filter to your Datomic query. Filters are known as expression clause
+    # predicates in the {Datomic query documentation}[http://docs.datomic.com/query.html].
+    #
+    # A filter can be in one of two forms. In the first, you pass a
+    # series of arguments. Any Ruby symbol given in this form will be
+    # converted to a EDN symbol. If the symbol is the same as one of
+    # the queried model's attributes or as a key passed to +where+, it
+    # will be prefixed with a +?+ so that it becomes a Datalog
+    # variable. In the second form, you pass
+    # {EDN}[https://github.com/relevance/edn-ruby] representing a
+    # Datomic predicate to +filter+. No conversion is done on this
+    # filter and it must be an EDN list.
+    #
+    # @example Passing arguments to be converted.
+    #   query.filter(:>, :age, 21)
+    #
+    # @example Passing EDN, which will not be converted.
+    #   query.filter(EDN::Type::List.new(EDN::Type::Symbol(">"),
+    #                                    EDN::Type::Symbol("?age"),
+    #                                    21))
+    #   # or, more simply
+    #   query.filter(~[~">", ~"?age", 21])
+    #
+    # @param filter [Array] Either one +EDN::Type::List+ or a number of arguments
+    #   that will be converted into a Datalog query.
+    # @return [Query]
+    def filter(*filter)
+      return peer_filter(filter) if self.model.instance_variable_get("@peer")
+      query = self.dup
+
+      if filter.first.is_a?(EDN::Type::List)
+        filter = filter.first
+      else
+        filter = filter.map { |e| convert_filter_element(e) }
+        filter = EDN::Type::List.new(*filter)
+      end
+
+      query.filters += [[filter]]
+      query
+    end
+
+    def peer_filter(*filter)
+      query = self.dup
+
+      if filter.first.is_a?(Array)
+        filter = filter.first
+      end
+      filter_attrs << filter[1].to_s
+      filter[1] = "?#{filter[1].to_s}"
+      filter = filter.tap {|e| e.to_s }.join(" ")
+      filter = "[(#{filter})]"
+
+      query.filters << filter
+      query
+    end
+
+
+    # Loop through the query results. In order to use +each+, your model *must*
+    # include a persistence API. At a minimum, it must have a +.q+ method that
+    # returns an +Enumerable+ object.
+    #
+    # @yield [Entity] An instance of the model passed to +Query+.
+    def each
+      # TODO check to see if the model has a `.q` method and give
+      # an appropriate error if not.
+      res = model.q(*data, @conn_or_db)
+      collapse_results(res).each do |entity|
+        if self.model.instance_variable_get("@peer") && @resolve
+          yield model.from_dbid_or_entity(entity.first.to_java, @conn_or_db, @resolve)
+        elsif self.model.instance_variable_get("@peer")
+          yield entity.first.to_java
+        # The map is for compatibility with Java peer persistence.
+        # TODO remove if possible
+        else
+          yield model.from_query(entity.map { |x| x }, @conn_or_db, @resolve)
+        end
+      end
+    end
+
+    # Return all query results.
+    #
+    # @return [Array<Entity>] Query results.
+    def all
+      map { |x| x }
+    end
+
+    # Create a Datomic query from the conditions and filters passed to this
+    # +Query+ object.
+    #
+    # @return [Array(Array, Array)] The first element of the array returned
+    #   is the Datomic query composed of Ruby data. The second element is
+    #   the arguments that used with the query.
+    def data
+      return peer_data if self.model.instance_variable_get("@peer")
+
+      vars = model.attribute_names.map { |attribute| ~"?#{attribute}" }
+
+      from = conditions.map { |k, _| ~"?#{k}" }
+
+      clauses = model.attribute_names.map { |attribute|
+        [~"?e", model.namespace(model.prefix, attribute), ~"?#{attribute}"]
+      }
+      clauses += filters
+
+      args = conditions.map { |_, v| v }
+
+      query = [
+        :find, ~"?e", *vars,
+        :in, ~"\$", *from,
+        :where, *clauses
+      ]
+
+      [query, args]
+    end
+
+    def peer_data
+      if conditions.empty? && filters.empty?
+        args = [model.prefix]
+        query = <<-EOQ
+[:find ?e
+ :in $ [?include-ns ...]
+ :where
+ [?e ?aid ?v]
+ [?aid :db/ident ?a]
+ [(namespace ?a) ?ns]
+ [(= ?ns ?include-ns)]]
+EOQ
+      else
+        unless conditions.empty?
+          clauses = conditions.keys.inject("") do |memo, attribute|
+            memo + "[?e " + model.namespace(model.prefix, attribute) + " ?#{attribute} ] "
+          end
+          from = conditions.inject("[") {|memo, kv| memo + "?#{kv.shift} "} +"]"
+          args = conditions.map { |_, v| v }
+        end
+
+        unless filter_attrs.empty?
+          clauses ||= ""
+          clauses = filter_attrs.inject(clauses) do |memo, attribute|
+            memo + "[?e " + model.namespace(model.prefix, attribute) + " ?#{attribute} ] "
+          end
+        end
+        query = "[:find ?e :in $ #{from} :where #{clauses} #{filters.join}]"
+      end
+
+      [query, args]
+    end
+
+    protected
+
+    def conditions=(conditions)
+      @conditions = conditions
+    end
+
+    def filters=(filters)
+      @filters = filters
+    end
+
+    def convert_filter_element(element)
+      if element.is_a?(Symbol)
+        if model.attribute_names.include?(element) || @conditions.keys.include?(element)
+          EDN::Type::Symbol.new("?#{element}")
+        else
+          EDN::Type::Symbol.new(element.to_s)
+        end
+      else
+        element
+      end
+    end
+
+    def collapse_results(res)
+      return res unless @resolve
+
+      res.group_by(&:first).map do |dbid, results|
+        # extract dbid from results
+        # NOTE: we prefer to_a.drop(1) over block arg decomposition because
+        #       result may be a Java::ClojureLang::PersistentVector
+        results = results.map {|result| result.to_a.drop(1) }
+
+        unless results.flatten.empty?
+          # Group values from all results into one result set
+          # [["b", 123], ["c", 123]] #=> [["b", "c"], [123, 123]]
+          grouped_values = results.transpose
+          attr_grouped_values = grouped_values[0...model.attributes.size]
+          enum_grouped_values = grouped_values[model.attributes.size..-1]
+
+          # Attach attribute names to each collection of values
+          # => [[:letters, ["b", "c"]], [:number, [123, 123]]]
+          attr_to_values = model.attributes.keys.zip(attr_grouped_values)
+
+          # Retain cardinality/many attributes as a collection,
+          # but pick only one value for cardinality/one attributes
+          collapsed_values = attr_to_values.map do |attr, values|
+            if model.attributes[attr][:cardinality] == :many
+              values
+            elsif model.attributes[attr][:value_type] == "ref" &&
+                model.enum_names.include?(attr)
+              enum_grouped_values.shift.first
+            else
+              values.first
+            end
+          end
+
+          # Returning a singular result for each dbid
+          [dbid, *collapsed_values]
+        else
+          [dbid]
+        end
+      end
+    end
+  end
+end

data/lib/diametric/railtie.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require "diametric"
+require "diametric/config"
+
+require "rails"
+
+require 'diametric/generators/active_model'
+
+module Rails
+  module Diametric
+    class Railtie < Rails::Railtie
+
+      config.app_generators.orm :diametric
+
+      # Initialize Diametric. This will look for a diametric.yml in the config
+      # directory and configure diametric appropriately.
+      initializer "setup database" do
+        config_file = Rails.root.join("config", "diametric.yml")
+        if config_file.file?
+          begin
+            ::Diametric::Config.load_and_connect!(config_file)
+          rescue Exception => e
+            handle_configuration_error(e)
+          end
+        end
+      end
+
+      # After initialization we will warn the user if we can't find a diametric.yml and
+      # alert to create one.
+      initializer "warn when configuration is missing" do
+        config.after_initialize do
+          unless Rails.root.join("config", "diametric.yml").file? || ::Diametric::Config.configured?
+            puts "\nDiametric config not found. Create a config file at: config/diametric.yml"
+            puts "to generate one run: rails generate diametric:config\n\n"
+          end
+        end
+      end
+      rake_tasks do
+        require "#{File.join(File.dirname(__FILE__), "..", "tasks", "create_schema.rb")}"
+        require "#{File.join(File.dirname(__FILE__), "..", "tasks", "diametric_config.rb")}"
+      end
+      # Rails runs all initializers first before getting into any generator
+      # code, so we have no way in the initializer to know if we are
+      # generating a diametric.yml. So instead of failing, we catch all the
+      # errors and print them out.
+      def handle_configuration_error(e)
+        puts "There is a configuration error with the current diametric.yml."
+        puts e.message
+      end
+    end
+  end
+end

data/lib/diametric/rest_service.rb

@@ -0,0 +1,74 @@
+require 'diametric/service_base'
+
+module Diametric
+  class RestService
+    include ::Diametric::ServiceBase
+    class << self
+      def datomic_command(datomic_home)
+        classpath = datomic_classpath(datomic_home)
+        command = ["java -server -Xmx1g", "-cp", classpath, "clojure.main", "-i", "#{datomic_home}/bin/bridge.clj", "--main datomic.rest"].flatten.join(" ")
+      end
+    end
+
+    attr_accessor :datomic_version, :datomic_version_no, :datomic_home, :pid
+    attr_accessor :host, :port, :db_alias, :uri
+
+   def initialize(conf="datomic_version.yml", dest="vendor/datomic")
+      @conf = conf
+      @dest = dest
+      @datomic_version = RestService.datomic_version(conf)
+      @datomic_home = File.join(File.dirname(__FILE__), "../..", dest, @datomic_version)
+      @datomic_version_no = RestService.datomic_version_no(@datomic_version)
+      @pid = nil
+    end
+
+    def start(opts={})
+      return if @pid
+      RestService.download(@conf, @dest)
+      command = RestService.datomic_command(@datomic_home)
+
+      require 'socket'
+      @host = opts[:host] ? opts[:host] : Socket.gethostname
+      @port = opts[:port] ? opts[:port] : 9000
+      @db_alias = opts[:db_alias] ? opts[:db_alias] : "free"
+      @uri = opts[:uri] ? opts[:uri] : "datomic:mem://"
+
+      uri = URI("http://#{@host}:#{@port}/")
+
+      unless port_available?(uri)
+        puts "Somebody is using #{@port}. Choose other."
+        return
+      end
+
+      temp_pid = spawn("#{command} -p #{@port} #{@db_alias} #{@uri}")
+
+      @pid = temp_pid if ready?(uri)
+    end
+
+    def stop
+      Process.kill("HUP", @pid) if @pid
+      @pid = nil
+    end
+
+    def port_available?(uri)
+      response = Net::HTTP.get_response(uri)
+      false
+    rescue Errno::ECONNREFUSED
+      true
+    end
+
+    def ready?(uri)
+      while true
+        begin
+          response = Net::HTTP.get_response(uri)
+          return true
+        rescue
+          sleep 1
+          redo
+        end
+      end
+      true
+    end
+
+  end
+end

data/lib/diametric/service_base.rb

@@ -0,0 +1,77 @@
+require 'net/http'
+require 'pathname'
+require 'yaml'
+
+module Diametric
+  module ServiceBase
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def datomic_conf_file?(file="datomic_version.yml")
+        if Pathname.new(file).relative?
+          file = File.join(File.dirname(__FILE__), "../..", file)
+        end
+        return File.exists?(file)
+      end
+
+      def datomic_version(conf="datomic_version.yml")
+        if datomic_conf_file?(conf)
+          datomic_names = File.read(File.join(File.dirname(__FILE__), "../..", conf))
+          datomic_versions = YAML.load(datomic_names)
+          if ENV['DIAMETRIC_ENV'] && (ENV['DIAMETRIC_ENV'] == "pro")
+            datomic_versions["pro"]
+          else
+            datomic_versions["free"]
+          end
+        else
+          conf
+        end
+      end
+
+      def datomic_version_no(datomic_version_str)
+        /(\d|\.)+/.match(datomic_version_str)[0]
+      end
+
+      def downloaded?(conf="datomic_version.yml", dest="vendor/datomic")
+        datomic_home = datomic_version(conf)
+        if Pathname.new(dest).relative?
+          dest = File.join(File.dirname(__FILE__), "..", "..", dest)
+        end
+        File.exists?(File.join(dest, datomic_home))
+      end
+
+      def download(conf="datomic_version.yml", dest="vendor/datomic")
+        return true if downloaded?(conf, dest)
+        version = datomic_version(conf)
+        url = "http://downloads.datomic.com/#{datomic_version_no(version)}/#{version}.zip"
+        if Pathname.new(dest).relative?
+          dest = File.join(File.dirname(__FILE__), "../..", dest)
+        end
+        require 'open-uri'
+        require 'zip/zipfilesystem'
+        open(url) do |zip_file|
+          Zip::ZipFile.open(zip_file.path) do |zip_path|
+            zip_path.each do |zip_entry|
+              file_path = File.join(dest, zip_entry.to_s)
+              FileUtils.mkdir_p(File.dirname(file_path))
+              zip_path.extract(zip_entry, file_path) { true }
+            end
+          end
+        end
+      end
+
+      def datomic_classpath(datomic_home)
+        # Find jar archives
+        jars = Dir["#{datomic_home}/lib/*.jar"]
+        jars += Dir["#{datomic_home}/*transactor*.jar"]
+
+        # Setup CLASSPATH
+        classpath = jars.join(File::PATH_SEPARATOR)
+        files = ["samples/clj", "bin", "resources"]
+        classpath += File::PATH_SEPARATOR + files.collect {|f| datomic_home + "/" + f}.join(File::PATH_SEPARATOR)
+      end
+    end
+  end
+end