xnlogic 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 228227d4a324ef82abaa6dee535286df33108c12
+  data.tar.gz: d9a430dbd6b9d08cc251c1a0264ed95fde17d765
+SHA512:
+  metadata.gz: 644272798d732f21d5f1be96da46a14b3d70b5036ba2713460c8cb49404041a42a06b0148ef51fe51fa1c69bc5ee15134444e99557f2996566249857c128e56c
+  data.tar.gz: 7a87b081194d30a86f416f66fc9f0f7dd128d181600933f2974d9cce809169a4bfd7e18214f406bdf4a6ac1c70a94d600bf85584b4572f8b248ec1cd3a14bcaa

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xnlogic.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Darrick Wiebe
+
+MIT License
+
+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 @@
+# Xnlogic
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'xnlogic'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xnlogic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/xnlogic/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,43 @@
+require "bundler/gem_tasks"
+
+require 'xn_gem_release_tasks'
+XNGemReleaseTasks.setup Xnlogic, 'lib/xnlogic/version.rb'
+
+begin
+  require 'ronn'
+
+  namespace :man do
+    directory "lib/xnlogic/man"
+
+    Dir["man/*.ronn"].each do |ronn|
+      basename = File.basename(ronn, ".ronn")
+      roff = "lib/xnlogic/man/#{basename}"
+
+      file roff => ["lib/xnlogic/man", ronn] do
+        sh "#{Gem.ruby} -S ronn --roff --pipe #{ronn} > #{roff}"
+      end
+
+      file "#{roff}.txt" => roff do
+        sh "groff -Wall -mtty-char -mandoc -Tascii #{roff} | col -b > #{roff}.txt"
+      end
+
+      task :build_all_pages => "#{roff}.txt"
+    end
+
+    desc "Build the man pages"
+    task :build => "man:build_all_pages"
+
+    desc "Clean up from the built man pages"
+    task :clean do
+      rm_rf "lib/xnlogic/man"
+    end
+  end
+
+rescue LoadError
+  namespace :man do
+    task(:build) { warn "Install the ronn gem to be able to release!" }
+    task(:clean) { warn "Install the ronn gem to be able to release!" }
+  end
+end
+
+task :build => ['man:clean', 'man:build']

data/bin/xnlogic

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+# Exit cleanly from an early interrupt
+Signal.trap("INT") { exit 1 }
+
+require 'xnlogic'
+
+require 'xnlogic/friendly_errors'
+Xnlogic.with_friendly_errors do
+  require 'xnlogic/cli'
+  Xnlogic::CLI.start(ARGV, :debug => true)
+end
+

data/lib/xnlogic/cli/application.rb

@@ -0,0 +1,60 @@
+require 'pathname'
+
+module Xnlogic
+  class CLI::Application
+    attr_reader :options, :app_name, :thor, :name, :target
+
+    def initialize(options, app_name, thor)
+      @options = options
+      @app_name = app_name
+      @thor = thor
+
+      @name = app_name.chomp("/").tr('-', '_') # remove trailing slash if present
+      @target = Pathname.pwd.join(name)
+    end
+
+    def run
+      namespaced_path = name
+      constant_name = namespaced_path.split('_').map{|p| p[0..0].upcase + p[1..-1] }.join
+      git_user_name = `git config user.name`.chomp
+      git_user_email = `git config user.email`.chomp
+
+      opts = {
+        :name            => name,
+        :namespaced_path => namespaced_path,
+        :constant_name   => constant_name,
+        :author          => git_user_name.empty? ? "TODO: Write your name" : git_user_name,
+        :email           => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
+      }
+
+      templates = {
+        "gitignore.tt" => ".gitignore",
+        ".rspec.tt" => ".rspec",
+        "Gemfile.tt" => "Gemfile",
+        "Readme.md.tt" => "Readme.md",
+        "lib/gemname.rb.tt" => "lib/#{namespaced_path}.rb",
+        "lib/gemname/version.rb.tt" => "lib/#{namespaced_path}/version.rb",
+        "lib/gemname/initializers/inflections.rb.tt" => "lib/#{namespaced_path}/initializers/inflections.rb",
+        "lib/gemname/parts/has_notes.rb.tt" => "lib/#{namespaced_path}/parts/has_notes.rb",
+        "lib/gemname/parts/note.rb.tt" => "lib/#{namespaced_path}/parts/note.rb",
+        "lib/gemname/type/url.rb.tt" => "lib/#{namespaced_path}/type/url.rb",
+        "lib/gemname/fixtures.rb.tt" => "lib/#{namespaced_path}/fixtures.rb",
+        "lib/gemname/models.rb.tt" => "lib/#{namespaced_path}/models.rb",
+        "lib/gemname/permissions.rb.tt" => "lib/#{namespaced_path}/permissions.rb",
+        "lib/gemname/type.rb.tt" => "lib/#{namespaced_path}/type.rb",
+        "lib/fixtures/sample_fixtures.rb.tt" => "lib/fixtures/sample_fixtures.rb",
+
+        "spec/spec_helper.rb.tt" => "spec/spec_helper.rb",
+        "spec/gemname/gemname_spec.rb.tt" => "spec/#{namespaced_path}/#{name}_spec.rb",
+      }
+
+      templates.each do |src, dst|
+        thor.template("application/#{src}", target.join(dst), opts)
+      end
+
+      Xnlogic.ui.info "Initializing git repo in #{target}"
+      Dir.chdir(target) { `git init`; `git add .` }
+    end
+  end
+end
+

data/lib/xnlogic/cli.rb

@@ -0,0 +1,73 @@
+require 'thor'
+
+module Xnlogic
+  class CLI < Thor
+    include Thor::Actions
+
+    def self.start(*)
+      super
+    rescue Exception => e
+      Xnlogic.ui = UI::Shell.new
+      raise e
+    end
+
+    def initialize(*args)
+      super
+    rescue UnknownArgumentError => e
+      raise InvalidOption, e.message
+    ensure
+      self.options ||= {}
+      Xnlogic.ui = UI::Shell.new(options)
+      Xnlogic.ui.level = "debug" if options["verbose"]
+    end
+
+    check_unknown_options!(:except => [:config, :exec])
+
+    # Stop parsing of options as soon as an unknown option or a regular argument is encountered. All remaining arguments are passed to the task. This
+    # is useful if you have a task that can receive arbitrary additional options, and where those additional options should not be handled by Thor.
+    stop_on_unknown_option! :exec
+
+    class_option "no-color", :type => :boolean, :banner => "Disable colorization in output"
+
+    class_option "verbose",  :type => :boolean, :banner => "Enable verbose output mode", :aliases => "-V"
+
+    def help(cli = nil)
+      case cli
+      when nil       then command = "xnlogic"
+      else                command = "xnlogic-#{cli}"
+      end
+
+      manpages = %w(
+          xnlogic)
+
+      if manpages.include?(command)
+        root = File.expand_path("../man", __FILE__)
+
+        if Xnlogic.which("man") && root !~ %r{^file:/.+!/META-INF/jruby.home/.+}
+          Kernel.exec "man #{root}/#{command}"
+        else
+          puts File.read("#{root}/#{command}.txt")
+        end
+      else
+        super
+      end
+    end
+
+    def self.handle_no_command_error(command, has_namespace = $thor_runner)
+      return super unless command_path = Xnlogic.which("xnlogic-#{command}")
+
+      Kernel.exec(command_path, *ARGV[1..-1])
+    end
+
+    desc "application NAME [OPTIONS]", "Creates a skeleton for creating an XN Logic application"
+    def application(name)
+      require 'xnlogic/cli/application'
+      Application.new(options, name, self).run
+    end
+
+    def self.source_root
+      File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+    end
+
+  end
+end

data/lib/xnlogic/friendly_errors.rb

@@ -0,0 +1,50 @@
+require "thor"
+
+# Create Thor classes if they don't exist already
+class Thor
+  class AmbiguousTaskError; end
+  class UndefinedTaskError; end
+  class Error; end
+end
+
+module Xnlogic
+  def self.with_friendly_errors
+    yield
+  rescue Xnlogic::XnlogicError => e
+    Xnlogic.ui.error e.message, :wrap => true
+    Xnlogic.ui.trace e
+    exit e.status_code
+  rescue Thor::AmbiguousTaskError => e
+    Xnlogic.ui.error e.message
+    exit 15
+  rescue Thor::UndefinedTaskError => e
+    Xnlogic.ui.error e.message
+    exit 15
+  rescue Thor::Error => e
+    Xnlogic.ui.error e.message
+    exit 1
+  rescue LoadError => e
+    raise e unless e.message =~ /cannot load such file -- openssl|openssl.so|libcrypto.so/
+    Xnlogic.ui.error "\nCould not load OpenSSL."
+    Xnlogic.ui.warn <<-WARN, :wrap => true
+      You must recompile Ruby with OpenSSL support or change the sources in your \
+      Gemfile from 'https' to 'http'. Instructions for compiling with OpenSSL \
+      using RVM are available at http://rvm.io/packages/openssl.
+    WARN
+    Xnlogic.ui.trace e
+    exit 1
+  rescue Interrupt => e
+    Xnlogic.ui.error "\nQuitting..."
+    Xnlogic.ui.trace e
+    exit 1
+  rescue SystemExit => e
+    exit e.status
+  rescue Exception => e
+    Xnlogic.ui.error <<-ERR, :wrap => true
+      Unfortunately, a fatal error has occurred. Please see the XN Logic \
+      ZenDesk support pages: https://xnlogic.zendesk.com/hc/en-us
+    ERR
+    raise e
+  end
+end
+

data/lib/xnlogic/man/xnlogic

@@ -0,0 +1,46 @@
+.\" generated with Ronn/v0.7.3
+.\" http://github.com/rtomayko/ronn/tree/0.7.3
+.
+.TH "XNLOGIC" "1" "November 2014" "" ""
+.
+.SH "NAME"
+\fBxnlogic\fR \- XN Logic Command\-line Tools
+.
+.SH "SYNOPSIS"
+\fBxnlogic\fR COMMAND [\-\-no\-color] [\-\-verbose] [ARGS]
+.
+.SH "DESCRIPTION"
+XN Logic is a graph database\-backed application framework\.
+.
+.P
+See the XN Logic website \fIhttps://xnlogic\.com\fR for information on getting started, or https://xnlogic\.zendesk\.com/hc/en\-us for support\.
+.
+.SH "OPTIONS"
+.
+.TP
+\fB\-\-no\-color\fR
+Prints all output without color
+.
+.TP
+\fB\-\-verbose\fR
+Prints out additional logging information
+.
+.SH "COMMANDS"
+We divide \fBxnlogic\fR subcommands into primary commands and utilities\.
+.
+.SH "PRIMARY COMMANDS"
+.
+.IP "\(bu" 4
+\&\.\.\.
+.
+.IP "\(bu" 4
+\fBxnlogic help(1)\fR: Displays detailed help for each subcommand
+.
+.IP "" 0
+.
+.SH "UTILITIES"
+.
+.TP
+\fBxnlogic application(1)\fR
+Create a simple application, suitable for development with xnlogic
+

data/lib/xnlogic/man/xnlogic.txt

@@ -0,0 +1,42 @@
+XNLOGIC(1)							    XNLOGIC(1)
+
+
+
+NAME
+       xnlogic - XN Logic Command-line Tools
+
+SYNOPSIS
+       xnlogic COMMAND [--no-color] [--verbose] [ARGS]
+
+DESCRIPTION
+       XN Logic is a graph database-backed application framework.
+
+       See the XN Logic website https://xnlogic.com for information on getting
+       started, or https://xnlogic.zendesk.com/hc/en-us for support.
+
+OPTIONS
+       --no-color
+	      Prints all output without color
+
+       --verbose
+	      Prints out additional logging information
+
+COMMANDS
+       We divide xnlogic subcommands into primary commands and utilities.
+
+PRIMARY COMMANDS
+       o   ...
+
+       o   xnlogic help(1): Displays detailed help for each subcommand
+
+
+
+UTILITIES
+       xnlogic application(1)
+	      Create a	simple	application,  suitable	for  development  with
+	      xnlogic
+
+
+
+
+				 November 2014			    XNLOGIC(1)

data/lib/xnlogic/templates/application/.rspec.tt

@@ -0,0 +1,2 @@
+-f d
+-p

data/lib/xnlogic/templates/application/Gemfile.tt

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem 'pacer'
+gem 'pacer-neo4j'
+gem 'pacer-model'
+gem 'pacer-mcfly'

data/lib/xnlogic/templates/application/Readme.md.tt

@@ -0,0 +1,86 @@
+# <%= config[:name] %>
+
+This gem provides the domain model and business logic for ...
+
+# Getting a New Environment Set Up
+
+TODO: Add vagrant setup instructions.
+
+# Starting up the Development Console
+
+To use this model, simply require the gem and work the graph like you're used to with pacer.
+
+To start an IRB console session in the terminal, log into the VM and:
+
+```
+  xn console <%= config[:name] %>
+```
+
+The first time you use the application, you must instantiate a client application. To do that from the console:
+
+```ruby
+  PM.create_client '<%= config[:name] %>', 'client_app_name'
+```
+
+You can create as many clients for your application as you like. Once you create a client, it will still be available across restarts of the
+application. To get a reference to your client application and the graph that it points to, run:
+
+```ruby
+  app = PM['client_app_name']
+  graph = app.graph
+```
+
+And that's it!  Now just rock your XN skills and Pacer-foo on top of your application model ;)
+
+## Testing the REST API within the Dev Console
+
+Start by getting a reference to the application instance (see above). Once you have that, you'll need to get XN to generate the
+console REST endpoints with this command:
+
+```ruby
+  include app.console
+```
+
+Now you can execute commands with `xget`, `xpost`, `xpatch`, `xdelete`, `xput`, as follows:
+
+```ruby
+  xget '/model/some_model/id/123'
+
+  # NOTE that hash keys in requests must be strings:
+
+  xput '/model/some_model', {'name' => 'Record Name'}
+```
+
+
+# Fixtures
+
+You can create fixture data for your app or for a sample app by creating fixture files in
+`lib/fixtures`. Run `xn sample_fixtures` to see a sample fixtures file.
+
+Load:
+
+```ruby
+  require 'gemname/fixtures.rb'
+  GemName::Fixtures.load_fixtures app
+```
+
+# Export to GraphML
+
+(yFiles)[http://www.yworks.com/en/products_yed_about.html] (yfiles will not recognize the file with an incorrect extension):
+
+```ruby
+  require 'pacer/utils/y_files'
+  exp = Pacer::Util::YFiles.new
+  exp.export graph, "/tmp/example.graphml"
+```
+
+
+Also, you can load and GraphML back into the graph with:
+
+```ruby
+  Pacer::GraphML.import graph, "/tmp/example.graphml"
+```
+
+# Copyright
+Copyright XN Logic Corporation, 2014. All rights reserved.
+Contact us@xnlogic.com for usage restrictions.

data/lib/xnlogic/templates/application/gitignore.tt

@@ -0,0 +1,9 @@
+*.sw?
+*.gem
+.bundle
+Gemfile.lock
+Jarfile.lock
+Jarfile.*.lock
+pkg/*
+bin/*
+tmp/

data/lib/xnlogic/templates/application/lib/fixtures/sample_fixtures.rb.tt

@@ -0,0 +1,53 @@
+module <%= config[:constant_name] %>
+  module Fixtures
+
+    # TODO: create your own fixtures!
+    class UsersFixture < Fixture
+      # We define that the UsersFixture depends on the GroupsFixture
+      def self.depends_on
+        [:GroupsFixture]
+      end
+
+      # This method is optional. Use it to clean up fixture data.
+      #
+      # NB: This is called each time before load is called.
+      def delete
+        app.find(<%= config[:constant_name] %>::M::UserAccount, 'david').delete!
+        app.find(<%= config[:constant_name] %>::M::UserAccount, 'darrick').delete!
+      end
+
+      def load
+        # This fixture method just calls the helper defined below
+        create_user 'david', 'David Colebatch', 'dc@xnlogic.com', ['support']
+        create_user 'darrick', 'Darrick Wiebe', 'dw@xnlogic.com', ['support']
+      end
+
+      private # HELPERS
+
+      # This is just a helper method to demonstrate that fixtures are just regular Ruby code.
+      def create_user(id, name, email, groups)
+        groups = groups.map { |g| app.find(<%= config[:constant_name] %>::M::Group, g) }
+        app.create(<%= config[:constant_name] %>::M::UserAccount, id, name: name, email: email) do |user|
+          groups.each do |group|
+            user.inherit_full_access group
+          end
+        end
+      end
+    end
+
+
+    class GroupsFixture < Fixture
+      # This method is optional. Use it to clean up fixture data.
+      #
+      # NB: This is called each time before load is called.
+      def delete
+        app.find(<%= config[:constant_name] %>::M::Group, 'support').delete!
+      end
+
+      def load
+        # We specify the Group model, an ID and then a list of property values:
+        app.create(<%= config[:constant_name] %>::M::Group, 'support', name: 'XN Logic Support')
+      end
+    end
+  end
+end

data/lib/xnlogic/templates/application/lib/gemname/fixtures.rb.tt

@@ -0,0 +1,108 @@
+require 'tsort'
+
+module <%= config[:constant_name] %>
+  module Fixtures
+    class Fixture
+      class << self
+        include TSort
+
+        def inherited(klass)
+          @inherited ||= []
+          @inherited = (@inherited + [klass]).sort_by &:name
+        end
+
+        def tsort_each_child(node, &block)
+          if node.respond_to? :depends_on
+            children = node.depends_on.flat_map do |n|
+              @inherited.select do |f|
+                f.name.split(/::/).last.to_sym == n
+              end
+            end
+            children.each &block
+          end
+        end
+
+        def tsort_each_node(&block)
+          @inherited.each &block if @inherited
+        end
+      end
+
+      attr_reader :app
+
+      def initialize(app, commit, rollback)
+        @app = app
+        @commit = commit
+        @rollback = rollback
+      end
+
+      def load
+        throw "Fixture #{ self.class.name } does nothing. Define a load method."
+      end
+
+      def delete
+      end
+
+      def commit
+        @commit.call
+      end
+
+      def rollback
+        @rollback.call
+      end
+    end
+  end
+end
+
+module <%= config[:constant_name] %>
+  module Fixtures
+    class << self
+      def load_fixtures(app)
+        delete_fixtures(app)
+        start_time = Time.now
+        app.graph.transaction do |commit, rollback|
+          <%= config[:constant_name] %>::Fixtures::Fixture.tsort.each do |fixture|
+            puts "Loading fixture: #{ fixture }"
+            f = fixture.new(app, commit, rollback)
+            f.load
+          end
+        end
+        puts "Loaded fixtures in #{ Time.now - start_time } seconds (#{app.graph.v.count} vertices, #{app.graph.e.count} edges)"
+      end
+
+      def delete_fixtures(app)
+        if app.graph.v.count > 300
+          raise "Error deleting fixture data. Node count > 300, possible production data."
+        end
+        reload_fixture_files
+        start_time = Time.now
+        app.create_indices!(app.graph)
+        app.graph.transaction do |commit, rollback|
+          <%= config[:constant_name] %>::Fixtures::Fixture.tsort.each do |fixture|
+            puts "Deleting fixture data: #{ fixture }"
+            fixture.new(app, commit, rollback).delete
+          end
+        end
+        app.generate_metadata!
+        puts "Deleted fixtures in #{ Time.now - start_time } seconds (#{app.graph.v.count} vertices, #{app.graph.e.count} edges)"
+      end
+
+      private
+
+      def fixtures_dir
+        <%= config[:constant_name] %>.lib_dir + 'fixtures'
+      end
+
+      def reload_fixture_files
+        if Dir[fixtures_dir + '*.rb'].any?
+          puts "Loading .rb fixtures from #{fixtures_dir}:"
+          Dir[fixtures_dir + '*.rb'].each do |path|
+            puts "Loading ruby file: #{path}"
+            load path
+          end
+        else
+          puts "Can't reload fixtures without the source code"
+        end
+      end
+    end
+  end
+end