xnlogic 1.0.0

data/lib/xnlogic/templates/application/lib/gemname/initializers/inflections.rb.tt

@@ -0,0 +1,13 @@
+# Some of our part/model names aren't inflected correctly by default.
+# Here we exclude them:
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.uncountable "media"
+  inflect.uncountable "software"
+
+  inflect.irregular "vrf", "vrfs"
+
+  inflect.acronym 'DNS'
+  inflect.acronym 'FEX'
+  inflect.acronym 'GW'
+  inflect.acronym 'GWs'
+end

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

@@ -0,0 +1,37 @@
+module <%= config[:constant_name] %>
+  module M
+  end
+
+  # NOTE: The ORDER that the class parts are specified in within each model
+  #       IS IMPORTANT here. If two parts define the same method, the one that is
+  #       included later will win. It can also call `super` because a real class
+  #       heirarchy is created.
+  #
+  #       Tools rely on models' parts being defined in order of significance.
+  #
+  # NOTE                                                          NOTE
+  # NOTE The LAST PART in the list SHOULD BEST DESCRIBE THE MODEL NOTE
+  # NOTE                       (if possible)                      NOTE
+  #
+  client_models = {
+    user_account:      [PacerModel::Extensions::Permission, PacerModel::Extensions::User],
+    group:             [PacerModel::Extensions::Permission, PacerModel::Extensions::Group],
+    token:             [PacerModel::Extensions::Token],
+    external_record:   [PacerModel::Extensions::ExternalRecord],
+    data_source:       [PacerModel::Extensions::DataSource],
+    import_record:     [PacerModel::Extensions::ImportRecord],
+    import:            [PacerModel::Extensions::Import],
+
+    # Metadata models
+    note:              [Note],
+  }
+
+  client_models.each do |name, parts|
+    <%= config[:constant_name] %>.models[name.to_s] = PacerModel::Model.new(:gemname,
+      name: name,
+      namespace: <%= config[:constant_name] %>::M,
+      core_parts: [PacerModel::Extensions::Record],
+      parts: ([HasNotes] + parts)
+    )
+  end
+end

data/lib/xnlogic/templates/application/lib/gemname/parts/has_notes.rb.tt

@@ -0,0 +1,10 @@
+module <%= config[:constant_name] %>
+  module HasNotes
+    xn_part
+
+    not_descriptive!
+    not_cloneable!
+
+    to_many :Note, custom_sort: proc { |a, b| b[:created_at] <=> a[:created_at] }
+  end
+end

data/lib/xnlogic/templates/application/lib/gemname/parts/note.rb.tt

@@ -0,0 +1,41 @@
+module <%= config[:constant_name] %>
+  module Note
+    xn_part
+
+    not_cloneable!
+
+    from_one PacerModel::Extensions::User, from: :author, to: :authored_notes, default: ->{ Thread.current[:context].current_user }
+    from_one :HasNotes
+
+    property :text, type: :text, filter: true
+
+    display :author_info do
+      if author
+        {
+          id: author.element_id,
+          name: author.name,
+          email: author.email,
+          email_md5: author.email_md5
+        }
+      end
+    end
+
+    action :delete_note, guard: :guard_delete_note do |ctx|
+      delete!
+    end
+
+    module Vertex
+      def guard_delete_note(errors)
+        if created_at < 15.minutes.ago
+          errors.add(:created_at, "Notes can only be deleted for 15 minutes")
+        end
+
+        if author != Thread.current[:context].current_user
+          errors.add(:author, "You can only delete notes you created")
+        end
+
+        # TODO Discuss the pros cons to having additional rules here, like only deleting the last note
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# This module maps out the groups to Part permissions.
+#
+# We define CRUD permissions as well as an 'action_access' permission and the scheme
+# is DENY all unless explicitly allowed by this matrix.
+#
+# NB: 'action_access' refers to both the 'action' and 'job' methods in PacerModel
+#     'read_access' includes the route_traversal, document and display methds
+#
+# Also, these permissions are merely the default. Clients may choose to modify them
+# in any way they wish.
+#
+# Some standard users and groups are also created in PacerModel::Application::Security.
+module <%= config[:constant_name] %>
+  module CreatePermissions
+    # Implementation details. See module/classes defined below.
+    def initialize(app)
+      @app = app
+    end
+    def load!
+      @app.graph.transaction(nesting: true) do
+        groups.inject({}) do |result, (key, name)|
+          result[key] = group key
+          result
+        end
+      end
+    end
+    # This method completely resets existing groups' permissions.
+    def group(key)
+      name = groups[key]
+      group = @app.find_or_create @app.group_model, name: name, key: key.to_s
+      group.revoke_access!
+      group.inherit_full_access [ @app.core_permissions_group ]
+      access_types.each do |access|
+        metaparts = send(key, access).map do |part|
+          mp = @app.find_metapart part
+          puts "WARNING: No metapart for #{ part.inspect }" unless mp
+          mp
+        end
+        group.send("add_#{ access }", metaparts.compact)
+      end
+    end
+    def access_types
+      [:create_access, :read_access, :update_access, :action_access, :delete_access]
+    end
+  end
+
+
+  # This module is used to create Groups of parts that can easily be assigned to
+  # user groups in the permission generation strategy classes, below:
+  module PartGroups
+    include <%= config[:constant_name] %>
+
+    # Use this method to determine if any of the app's parts are not part of
+    # any of the group definitions below.
+    def missing
+      @app.all_parts - internal_only - users - external - client_models
+    end
+
+    # Use this technique to group together subgroups of parts, which is very useful in larger, more complex models!
+    def client_models
+      base + note + comments
+    end
+
+    # NOTE: only the xnlogic administrator should have access to these
+    def internal_only
+      Set[ PacerModel::Extensions::Part, PacerModel::Extensions::Token,
+           PacerModel::Extensions::XnInfraAdmin ]
+    end
+
+    # Other parts that are built in to XN
+
+    def users
+      Set[ PacerModel::Extensions::Permission, PacerModel::Extensions::User, PacerModel::Extensions::Group ]
+    end
+
+    def external
+      Set[ PacerModel::Extensions::DataSource, PacerModel::Extensions::ExternalRecord ]
+    end
+
+    def base
+      Set[ PacerModel::Extensions::Record, HasNotes, PacerModel::Extensions::User, ]
+    end
+
+    # Your Application-specific parts should go in a bunch of groups starting here:
+
+    def note
+      Set[ Note, ]
+    end
+
+    def comments
+      # Placeholder for theoretical comments part...
+      Set[ ]
+    end
+  end
+
+
+  # A sophisticated role based access model
+  class RoleBasedPermissions
+    include CreatePermissions
+    include PartGroups
+
+    def initialize(app)
+      super
+    end
+
+    def groups
+      {
+        support: 'Support',
+        staff: 'Staff',
+        read_only: 'Read Only'
+      }
+    end
+
+    def support(access)
+      base + users + client_models
+    end
+
+    def read_only(access)
+      case access
+      when :read_access
+        base + client_models
+      else
+        []
+      end
+    end
+
+    def staff(access)
+      case access
+      when :delete_access
+        base + comments
+      when :read_access, :update_access, :create_access, :action_access
+        base + client_models
+      end
+    end
+  end
+end

data/lib/xnlogic/templates/application/lib/gemname/type/url.rb.tt

@@ -0,0 +1,13 @@
+module <%= config[:constant_name] %>
+  module Type
+
+    # URL can be a property's type
+    Property::URL = {
+      type: :text,
+      label: 'URL',
+    }.freeze
+
+    # URL can be an argument in an action as well. Definition is identical to Property::URL:
+    Argument::URL = Property::URL
+  end
+end

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

@@ -0,0 +1,10 @@
+module <%= config[:constant_name] %>
+  module Type
+    module Argument; end
+    module Property; end
+  end
+end
+
+# Specialized types
+require '<%= config[:namespaced_path] %>/type/url'
+

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

@@ -0,0 +1,3 @@
+module <%= config[:constant_name] %>
+  VERSION = "1.0.0"
+end

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

@@ -0,0 +1,116 @@
+if RUBY_VERSION == '1.8.7'
+  STDERR.puts <<WARNING
+WARNING: XN Logic is developed using JRuby in 1.9 mode. I recommend you
+  restart JRuby in 1.9 mode, either with the --1.9 flag, or by
+  defaulting to 1.9 mode by setting the environment variable
+  JRUBY_OPTS=--1.9
+WARNING
+  raise "1.8 mode: no go"
+end
+
+require 'rubygems'
+require 'bundler/setup'
+require 'active_model'
+require 'active_model/naming'
+require 'active_support/core_ext'
+require 'pacer'
+require 'pacer-model'
+require 'pathname'
+
+require '<%= config[:namespaced_path] %>/initializers/inflections'
+
+module <%= config[:constant_name] %>
+  VertexDsl = PacerModel::VertexDsl
+  START_TIME = Time.now unless const_defined? :START_TIME
+
+  class << self
+    include PacerModel::AppBase
+
+    def lib_dir
+      Pathname.new(File.expand_path(__FILE__)).parent
+    end
+
+    def sample_app(args)
+      unless args.is_a? Hash
+        puts "sample_app takes an args hash with :graph and :client_name required."
+        return
+      end
+      unless args.keys.include? :client_name and args.keys.include? :graph
+        puts ":graph and :client_name are required arguments"
+        return
+      end
+      require '<%= config[:namespaced_path] %>/fixtures'
+      Dir[<%= config[:constant_name] %>.lib_dir + "fixtures/*.{rb,class}"].each do |file|
+        require Pathname.new(file).relative_path_from(<%= config[:constant_name] %>.lib_dir)
+      end
+      a = app(args)
+      Fixtures.load_fixtures(a)
+      a
+    end
+
+    # Usage: permission_models[x].new(app).load!
+    # Note, it's load! method must be idempotent.
+    def permission_models
+      {
+        'role_based' => <%= config[:constant_name] %>::RoleBasedPermissions
+      }
+    end
+
+    # Returns the time pacer was last reloaded (or when it was started).
+    def reload_time
+      if defined? @reload_time
+        @reload_time
+      else
+        START_TIME
+      end
+    end
+
+    # Reload all Ruby modified files in the Pacer library. Useful for debugging
+    # in the console. Does not do any of the fancy stuff that Rails reloading
+    # does.  Certain types of changes will still require restarting the
+    # session.
+    def reload!
+      lib_dir.find do |path|
+        if path.extname == '.rb' and path.mtime > reload_time
+          puts path.to_s
+          load path.to_s rescue nil
+        end
+      end
+      @reload_time = Time.now
+    end
+  end
+end
+
+require '<%= config[:namespaced_path] %>/version'
+require '<%= config[:namespaced_path] %>/type'
+
+PacerModel.applications['<%= config[:name] %>'] = <%= config[:constant_name] %>
+PacerModel.property_namespaces << <%= config[:constant_name] %>::Type::Property
+PacerModel.argument_namespaces << <%= config[:constant_name] %>::Type::Argument
+PacerModel.part_namespaces << <%= config[:constant_name] %>
+PacerModel.on_part_registered << lambda do |part|
+  if part.name =~ /^<%= config[:constant_name] %>::/
+    <%= config[:constant_name] %>.parts[part.key.to_s] = part
+  end
+end
+
+#NOTE: meta contains some common parts. So, load meta first to ensure
+#      common parts are loaded into other parts on boot
+Dir[<%= config[:constant_name] %>.lib_dir + '<%= config[:namespaced_path] %>/meta/*.{class,rb}'].each do |file|
+  require Pathname.new(file).relative_path_from(<%= config[:constant_name] %>.lib_dir)
+end
+<%= config[:constant_name] %>.common_parts!
+# dirs under lib/<%= config[:namespaced_path] %> that contain groupings of parts
+sections = %w[
+  parts
+]
+
+# Now that we have DEFAULT_CONSTANTS being referenced, if load order is important...
+#require <%= config[:constant_name] %>.lib_dir + "<%= config[:namespaced_path] %>/group/part"
+
+Dir[<%= config[:constant_name] %>.lib_dir + "<%= config[:namespaced_path] %>/{#{sections.join ','}}/*.{rb,class}"].each do |file|
+  require Pathname.new(file).relative_path_from(<%= config[:constant_name] %>.lib_dir)
+end
+
+require '<%= config[:namespaced_path] %>/models'
+require '<%= config[:namespaced_path] %>/permissions'

data/lib/xnlogic/templates/application/spec/gemname/gemname_spec.rb.tt

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe <%= config[:constant_name] %> do
+  it 'should boot' do
+    <%= config[:constant_name] %>.should be_a Module
+  end
+end

data/lib/xnlogic/templates/application/spec/spec_helper.rb.tt

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development
+
+require '<%= config[:namespaced_path] %>'
+
+Bundler.require :development
+require 'pp'
+
+Dir['./spec/support/**/*.rb'].map {|f| require f}
+
+class RSpec::Core::ExampleGroup
+  def self.run_all(reporter=nil)
+    run(reporter || NullObject.new)
+  end
+end
+
+def in_editor?
+  ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
+end
+
+RSpec.configure do |c|
+  c.color_enabled = !in_editor?
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+  Pacer.hide_route_elements = true
+  Pacer.verbose = false
+  JRuby.objectspace = true
+  c.mock_with :rr
+
+  SpecApp = <%= config[:constant_name] %>.app graph: Pacer.tg, client_name: 'specs'
+  SpecApp.add_to_models!
+  SpecApp.add_to_parts!
+
+  puts "Using JRuby #{ JRUBY_VERSION } in #{ RUBY_VERSION } mode."
+end
+
+
+def use_simple_fixtures
+  before          { <%= config[:constant_name] %>.graph = Pacer.tg }
+  let(:graph)     { <%= config[:constant_name] %>.graph }
+  let(:manufacturer) { graph.create_vertex <%= config[:constant_name] %>::Manufacturer }
+  let(:device_model){ graph.create_vertex <%= config[:constant_name] %>::DeviceModel }
+end

data/lib/xnlogic/ui/shell.rb

@@ -0,0 +1,96 @@
+module Xnlogic
+  module UI
+    class Shell
+      LEVELS = %w(silent error warn confirm info debug)
+
+      attr_writer :shell
+
+      def initialize(options = {})
+        if options["no-color"] || !STDOUT.tty?
+          Thor::Base.shell = Thor::Shell::Basic
+        end
+        @shell = Thor::Base.shell.new
+        @level = ENV['DEBUG'] ? "debug" : "info"
+      end
+
+      def info(msg, newline = nil)
+        tell_me(msg, nil, newline) if level("info")
+      end
+
+      def confirm(msg, newline = nil)
+        tell_me(msg, :green, newline) if level("confirm")
+      end
+
+      def warn(msg, newline = nil)
+        tell_me(msg, :yellow, newline) if level("warn")
+      end
+
+      def error(msg, newline = nil)
+        tell_me(msg, :red, newline) if level("error")
+      end
+
+      def debug(msg, newline = nil)
+        tell_me(msg, nil, newline) if level("debug")
+      end
+
+      def debug?
+        # needs to be false instead of nil to be newline param to other methods
+        level("debug")
+      end
+
+      def quiet?
+        LEVELS.index(@level) <= LEVELS.index("warn")
+      end
+
+      def ask(msg)
+        @shell.ask(msg)
+      end
+
+      def level=(level)
+        raise ArgumentError unless LEVELS.include?(level.to_s)
+        @level = level
+      end
+
+      def level(name = nil)
+        name ? LEVELS.index(name) <= LEVELS.index(@level) : @level
+      end
+
+      def trace(e, newline = nil)
+        return unless debug?
+        msg = "#{e.class}: #{e.message}\n#{e.backtrace.join("\n  ")}"
+        tell_me(msg, nil, newline)
+      end
+
+      def silence
+        old_level, @level = @level, "silent"
+        yield
+      ensure
+        @level = old_level
+      end
+
+    private
+
+      # valimism
+      def tell_me(msg, color = nil, newline = nil)
+        msg = word_wrap(msg) if newline.is_a?(Hash) && newline[:wrap]
+        if newline.nil?
+          @shell.say(msg, color)
+        else
+          @shell.say(msg, color, newline)
+        end
+      end
+
+      def strip_leading_spaces(text)
+        spaces = text[/\A\s+/, 0]
+        spaces ? text.gsub(/#{spaces}/, '') : text
+      end
+
+      def word_wrap(text, line_width = @shell.terminal_width)
+        strip_leading_spaces(text).split("\n").collect do |line|
+          line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip : line
+        end * "\n"
+      end
+    end
+  end
+end
+

data/lib/xnlogic/ui/silent.rb

@@ -0,0 +1,45 @@
+module Xnlogic
+  module UI
+    class Silent
+      def info(message, newline = nil)
+      end
+
+      def confirm(message, newline = nil)
+      end
+
+      def warn(message, newline = nil)
+      end
+
+      def error(message, newline = nil)
+      end
+
+      def debug(message, newline = nil)
+      end
+
+      def debug?
+        false
+      end
+
+      def quiet?
+        false
+      end
+
+      def ask(message)
+      end
+
+      def level=(name)
+      end
+
+      def level(name = nil)
+      end
+
+      def trace(message, newline = nil)
+      end
+
+      def silence
+        yield
+      end
+    end
+  end
+end
+

data/lib/xnlogic/ui.rb

@@ -0,0 +1,7 @@
+module Xnlogic
+  module UI
+    autoload :Shell,   'xnlogic/ui/shell'
+    autoload :Silent,  'xnlogic/ui/silent'
+  end
+end
+

data/lib/xnlogic/version.rb

@@ -0,0 +1,3 @@
+module Xnlogic
+  VERSION = "1.0.0"
+end

data/lib/xnlogic.rb

@@ -0,0 +1,33 @@
+require 'xnlogic/version'
+require 'fileutils'
+require 'pathname'
+require 'xnlogic/ui'
+
+module Xnlogic
+  class XnlogicError < StandardError
+    def self.status_code(code)
+      define_method(:status_code) { code }
+    end
+  end
+
+  class InvalidOption         < XnlogicError; status_code(15) ; end
+
+  class << self
+    attr_writer :ui
+
+    def ui
+      @ui ||= UI::Silent.new
+    end
+
+    def which(executable)
+      if File.file?(executable) && File.executable?(executable)
+        executable
+      elsif ENV['PATH']
+        path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
+          File.executable?(File.join(p, executable))
+        end
+        path && File.expand_path(executable, path)
+      end
+    end
+  end
+end

data/man/xnlogic.ronn

@@ -0,0 +1,38 @@
+xnlogic(1) -- 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
+
+* ...
+
+* `xnlogic help(1)`:
+  Displays detailed help for each subcommand
+
+## UTILITIES
+
+* `xnlogic application(1)`:
+  Create a simple application, suitable for development with xnlogic
+