marklogic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ddad5d982939d5693742db6623e91f7d557de379
+  data.tar.gz: 77e4174a64065444b8a58408eeddfc3d7d23c879
+SHA512:
+  metadata.gz: ba515d4ec20bb8c9f22ff93749d2df9542d5803eb9622d7dea000de4edb6085c90da2a2cd4ecb8f24c0d1c2c2d7efdef62dcd1b56ab9f91bebc3dd5d99d25f30
+  data.tar.gz: 162f3f432d888b4ae47357c4345b68069a761b4c6fc14498922ecdbf4138d60c933c2a665602008eaa07a5ea33a9b0fd56dffd6864677f9961e3dd3d0acff16b

data/.editorconfig

@@ -0,0 +1,10 @@
+# http://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--order random

data/.ruby-gemset

@@ -0,0 +1 @@
+marklogic-gem

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in marklogic.gemspec
+gemspec
+
+group :development do
+  gem 'guard'
+  gem 'rspec'
+  gem 'rspec-nc', require: false
+
+  gem 'pry'
+  gem 'pry-byebug'
+
+  gem 'terminal-notifier-guard', require: false
+  gem 'guard-rspec'
+  gem 'guard-yard'
+end

data/Guardfile

@@ -0,0 +1,45 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard 'yard' do
+  watch(%r{app/.+\.rb})
+  watch(%r{lib/.+\.rb})
+  watch(%r{ext/.+\.c})
+end
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Paxton Hare
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Marklogic
+
+A MarkLogic connector for Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'marklogic'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install marklogic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/paxtonhare/marklogic/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/marklogic.rb

@@ -0,0 +1,21 @@
+require 'active_support'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/string/inflections'
+require "marklogic/version"
+require "marklogic/consts"
+require 'marklogic/queries'
+require 'marklogic/exceptions'
+require 'marklogic/object_id'
+
+module MarkLogic
+  autoload :Application, 'marklogic/application'
+  autoload :AppServer, 'marklogic/app_server'
+  autoload :Collection, 'marklogic/collection'
+  autoload :Connection, 'marklogic/connection'
+  autoload :Cursor, 'marklogic/cursor'
+  autoload :Database, 'marklogic/database'
+  autoload :DatabaseSettings, 'marklogic/database_settings'
+  autoload :Forest, 'marklogic/forest'
+  autoload :Loggable, 'marklogic/loggable'
+  autoload :Persistence, 'marklogic/persistence'
+end

data/lib/marklogic/app_server.rb

@@ -0,0 +1,60 @@
+module MarkLogic
+  class AppServer
+    include MarkLogic::Persistence
+
+    attr_accessor :server_name, :server_type, :group_name
+
+    def initialize(server_name, port, server_type = "http", group_name = "Default", options = {})
+      content_database = options[:content_database] || "#{server_name.gsub(/_/, "-")}-content"
+      modules_database = options[:modules_database] || "#{server_name.gsub(/_/, "-")}-modules"
+      self.connection = options[:connection]
+      self.admin_connection = options[:admin_connection]
+
+      @server_name = server_name
+      @server_type = server_type
+      @group_name = group_name
+
+      @options = {
+        "server-name" => @server_name,
+        "root" => options[:root] || "/",
+        "port" => port,
+        "content-database" => content_database,
+        "modules-database" => modules_database,
+        "url-rewriter" => "/MarkLogic/rest-api/rewriter.xml",
+        "error-handler" => "/MarkLogic/rest-api/error-handler.xqy",
+        "rewrite-resolves-globally" => true
+      }
+    end
+
+    def []=(key, value)
+      @options[key] = value
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def has_key?(key)
+      @options.has_key?(key)
+    end
+
+    def create
+      r = manage_connection.post_json(
+        %Q{/manage/v2/servers/?group-id=#{group_name}&server-type=#{server_type}&format=json},
+        @options)
+    end
+
+    def drop
+      r = manage_connection.delete(%Q{/manage/v2/servers/#{server_name}?group-id=#{group_name}&format=json})
+
+      # wait for restart
+      admin_connection.wait_for_restart(r.body) if r.code.to_i == 202
+
+      return r
+    end
+
+    def exists?
+      manage_connection.head(%Q{/manage/v2/servers/#{server_name}?group-id=#{group_name}}).code.to_i == 200
+    end
+  end
+end

data/lib/marklogic/application.rb

@@ -0,0 +1,244 @@
+module MarkLogic
+  class Application
+    include MarkLogic::Persistence
+
+    attr_accessor :app_name
+
+    def initialize(app_name, options = {})
+      @app_name = app_name
+      self.connection = options[:connection]
+      @port = options[:port] || self.connection.port
+      self.admin_connection = options[:admin_connection]
+    end
+
+    def create
+      logger.debug(%Q{Creating Application: #{@app_name}})
+
+      build_implicit_defs
+
+      databases.each do |database_name, database|
+        unless database.exists?
+          database.create
+        else
+          database.update
+        end
+      end
+
+      forests.each do |forest_name, forest|
+        forest.create unless forest.exists?
+      end
+
+      app_servers.each do |server_name, app_server|
+        app_server.create unless app_server.exists?
+      end
+
+    end
+
+    def create_indexes
+      build_implicit_defs
+
+      content_databases.each do |database|
+        if database.exists?
+          database.update
+        else
+          database.create
+        end
+      end
+    end
+
+    def sync
+      create if stale?
+    end
+
+    def sync!
+      create
+    end
+
+    def drop
+      logger.debug(%Q{Dropping Application: #{@app_name}})
+
+      build_implicit_defs
+
+      app_servers.each do |server_name, app_server|
+        app_server.drop if app_server.exists?
+      end
+
+      databases.each do |database_name, database|
+        if database.exists?
+          database.drop
+        end
+      end
+
+      forests.each do |forest_name, forest|
+        if forest.exists?
+          forest.drop
+        end
+      end
+    end
+
+    def exists?
+      build_implicit_defs
+
+      databases.each do |database_name, database|
+        return false if !database.exists?
+      end
+
+      forests.each do |forest_name, forest|
+        return false if !forest.exists?
+      end
+
+      app_servers.each do |server_name, app_server|
+        return false if !app_server.exists?
+      end
+
+      return true
+    end
+
+    def stale?
+      build_implicit_defs
+
+      databases.each do |database_name, database|
+        unless database.exists?
+          logger.debug "database: #{database_name} is missing"
+          return true
+        end
+      end
+
+      content_databases.each do |database|
+        if database.stale?
+          logger.debug "database: #{database.database_name} is stale"
+          return true
+        end
+      end
+
+      forests.each do |forest_name, forest|
+        unless forest.exists?
+          logger.debug "forest: #{forest_name} is missing"
+          return true
+        end
+      end
+
+      app_servers.each do |server_name, app_server|
+        unless app_server.exists?
+          logger.debug "app_server: #{server_name} is missing"
+          return true
+        end
+      end
+
+      return false
+    end
+
+    def forests
+      @forests ||= {}
+    end
+
+    def databases
+      @databases ||= {}
+    end
+
+    def app_servers
+      @app_servers ||= {}
+    end
+
+    def add_index(index)
+      indexes[index.key] = index
+    end
+
+    def clear_indexes()
+      content_databases.each do |database|
+        database.reset_indexes
+      end
+      @indexes = {}
+    end
+
+    def content_databases
+      app_servers.values.map do |app_server|
+        databases[app_server['content-database']]
+      end
+    end
+
+    def database(name)
+      database = MarkLogic::Database.new(name)
+      yield(database) if block_given?
+      logger.info("#{__LINE__}: db_name: #{name}")
+      databases[name] = database
+    end
+
+    def app_server(name)
+      app_server = MarkLogic::AppServer.new(name, @port)
+      yield(app_server) if block_given?
+      app_servers[name] = app_server
+    end
+
+    private
+
+    def indexes
+      @indexes ||= {}
+    end
+
+    def build_implicit_defs
+      build_appservers
+      build_databases
+      build_indexes
+    end
+
+    def build_appservers
+      if app_servers.empty?
+        app_servers[@app_name] = MarkLogic::AppServer.new(@app_name, @port, "http", "Default", :connection => self.connection, :admin_connection => admin_connection)
+      end
+    end
+
+    def build_databases
+      app_servers.each_value do |app_server|
+        db_name = app_server['content-database']
+        unless databases.has_key?(db_name)
+          db = MarkLogic::Database.new(db_name, self.connection)
+          db.application = self
+          databases[db_name] = db
+        end
+        forests[db_name] = MarkLogic::Forest.new(db_name, nil, self.connection) unless forests.has_key?(db_name)
+        forests[db_name].database = databases[db_name]
+
+        modules_db_name = app_server['modules-database']
+        unless databases.has_key?(modules_db_name)
+          modules_db = MarkLogic::Database.new(modules_db_name, self.connection)
+          modules_db.application = self
+          databases[modules_db_name] = modules_db
+        end
+        forests[modules_db_name] = MarkLogic::Forest.new(modules_db_name, nil, self.connection) unless forests.has_key?(modules_db_name)
+        forests[modules_db_name].database = databases[modules_db_name]
+      end
+
+      triggers_database = nil
+      schema_database = nil
+      databases.each_value do |database|
+        if database.has_key?('triggers-database')
+          logger.info "has triggers: [#{database['triggers-database']}]"
+          triggers_database = database['triggers-database']
+        end
+
+        if database.has_key?('schema-database')
+          schema_database = database['schema-database']
+        end
+      end
+
+      if triggers_database and !databases.has_key?(triggers_database)
+        databases[triggers_database] = MarkLogic::Database.new(triggers_database, self.connection)
+      end
+
+      if schema_database and !databases.has_key?(schema_database)
+        databases[schema_database] = MarkLogic::Database.new(schema_database, self.connection)
+      end
+    end
+
+    def build_indexes
+      content_databases.each do |database|
+        database.reset_indexes
+
+        indexes.clone.each do |key, index|
+          index.append_to_db(database)
+        end
+      end
+    end
+  end
+end