nose 0.1.0pre

data/lib/nose/model/fields.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'faker'
+require 'forwardable'
+require 'zlib'
+
+module NoSE
+  # Fields attached to each entity in the entity graph model
+  module Fields
+    # A single field on an {Entity}
+    class Field
+      include Supertype
+
+      attr_reader :name, :size, :parent
+      attr_accessor :primary_key
+      alias primary_key? primary_key
+
+      # The Ruby type of values stored in this field
+      TYPE = nil
+
+      def initialize(name, size, count: nil)
+        @name = name
+        @size = size
+        @cardinality = count
+        @primary_key = false
+      end
+
+      # Compare by parent entity and name
+      def ==(other)
+        other.is_a?(Field) && @parent == other.parent &&
+          @name == other.name
+      end
+      alias eql? ==
+
+      # Hash by entity and name
+      # @return [Fixnum]
+      def hash
+        @hash ||= id.hash
+      end
+
+      # :nocov:
+      def to_color
+        "[blue]#{@parent.name}[/].[blue]#{@name}[/]"
+      end
+      # :nocov:
+
+      # :nocov:
+      def to_s
+        "#{@parent.name}.#{@name}"
+      end
+      # :nocov:
+
+      # A simple string representing the field
+      def id
+        @id ||= "#{@parent.name}_#{@name}"
+      end
+
+      # Set the estimated cardinality of the field
+      # @return [Field]
+      def *(other)
+        @cardinality = other
+        self
+      end
+
+      # Return the previously set cardinality, falling back to the number of
+      # entities for the field if set, or just 1
+      def cardinality
+        @cardinality || @parent.count || 1
+      end
+
+      # @abstract Subclasses should produce a typed value from a string
+      # :nocov:
+      def self.value_from_string(_string)
+        fail NotImplementedError
+      end
+      # :nocov:
+
+      # @abstract Subclasses should produce a random value of the correct type
+      # :nocov:
+      def random_value
+        fail NotImplementedError
+      end
+      # :nocov:
+
+      # Populate a helper DSL object with all subclasses of Field
+      def self.inherited(child_class)
+        # We use separate methods for foreign keys
+        begin
+          fk_class = Fields.const_get('ForeignKeyField')
+        rescue NameError
+          fk_class = nil
+        end
+        return if !fk_class.nil? && child_class <= fk_class
+
+        add_field_method(child_class)
+        child_class.send(:include, Subtype)
+      end
+      private_class_method :inherited
+
+      # Add convenience methods for all field types for an entity DSL
+      def self.add_field_method(child_class)
+        method_regex = /^NoSE::Fields::(.*?)(Field)?$/
+        method_name = child_class.name.sub(method_regex, '\1')
+        EntityDSL.send :define_method, method_name,
+                       (proc do |*args|
+                         send(:instance_variable_get, :@entity).send \
+                           :<<, child_class.new(*args)
+                       end)
+      end
+      private_class_method :add_field_method
+    end
+
+    # Field holding an integer
+    class IntegerField < Field
+      # Integers are stored as integers
+      TYPE = Integer
+
+      def initialize(name, **options)
+        super(name, 8, **options)
+        @cardinality = 10
+      end
+
+      # Parse an Integer from the provided parameter
+      # @return [Fixnum]
+      def self.value_from_string(string)
+        string.to_i
+      end
+
+      # Random numbers up to the given size
+      # @return [Fixnum]
+      def random_value
+        rand(@cardinality)
+      end
+    end
+
+    # Field holding a boolean value
+    class BooleanField < Field
+      # Since Ruby has no boolean type, we use Object
+      # but all values will be either false or true
+      TYPE = Object
+
+      def initialize(name, **options)
+        super(name, 1, **options)
+        @cardinality = 2
+      end
+
+      # Check for strings true or false otherwise assume integer
+      # @return [Boolean]
+      def self.value_from_string(string)
+        string = string.downcase
+        if string[0] == 't'
+          return true
+        elsif string[0] == 'f'
+          return false
+        else
+          [false, true][string.to_i]
+        end
+      end
+
+      # Randomly true or false
+      # @return [Boolean]
+      def random_value
+        [false, true][rand(2)]
+      end
+    end
+
+    # Field holding a float
+    class FloatField < Field
+      # Any Fixnum is a valid float
+      TYPE = Fixnum
+
+      def initialize(name, **options)
+        super(name, 8, **options)
+      end
+
+      # Parse a Float from the provided parameter
+      def self.value_from_string(string)
+        string.to_f
+      end
+
+      # Random numbers up to the given size
+      def random_value
+        rand(@cardinality).to_f
+      end
+    end
+
+    # Field holding a string of some average length
+    class StringField < Field
+      # Strings are stored as strings
+      TYPE = String
+
+      def initialize(name, length = 10, **options)
+        super(name, length, **options)
+      end
+
+      # Return the String parameter as-is
+      # @return [String]
+      def self.value_from_string(string)
+        string
+      end
+
+      # A random string of the correct length
+      # @return [String]
+      def random_value
+        Faker::Lorem.characters(@size)
+      end
+    end
+
+    # Field holding a date
+    class DateField < Field
+      # Time is used to store timestamps
+      TYPE = Time
+
+      def initialize(name, **options)
+        super(name, 8, **options)
+      end
+
+      # Parse a DateTime from the provided parameter
+      # @return [Time]
+      def self.value_from_string(string)
+        # rubocop:disable Style/RedundantBegin
+        begin
+          DateTime.parse(string).to_time
+        rescue ArgumentError
+          raise TypeError
+        end
+        # rubocop:enable Style/RedundantBegin
+      end
+
+      # A random date within 2 years surrounding today
+      # @return [Time]
+      def random_value
+        prev_year = DateTime.now.prev_year
+        prev_year = prev_year.new_offset(Rational(0, 24))
+
+        next_year = DateTime.now.next_year
+        next_year = next_year.new_offset(Rational(0, 24))
+
+        Faker::Time.between prev_year, next_year
+      end
+    end
+
+    # Field representing a hash of multiple values
+    class HashField < Field
+      def initialize(name, size = 1, **options)
+        super(name, size, **options)
+      end
+    end
+
+    # Field holding a unique identifier
+    class IDField < Field
+      alias entity parent
+
+      def initialize(name, **options)
+        super(name, 16, **options)
+        @primary_key = true
+      end
+
+      # Return the String parameter as-is
+      # @return [String]
+      def self.value_from_string(string)
+        string
+      end
+
+      # nil value which is interpreted by the backend as requesting a new ID
+      # @return [nil]
+      def random_value
+        nil
+      end
+    end
+
+    # Field holding a foreign key to another entity
+    class ForeignKeyField < IDField
+      attr_reader :entity, :relationship
+      attr_accessor :reverse
+
+      def initialize(name, entity, **options)
+        @relationship = options.delete(:relationship) || :one
+        super(name, **options)
+        @primary_key = false
+        @entity = entity
+      end
+
+      # The number of entities associated with the foreign key,
+      # or a manually set cardinality
+      # @return [Fixnum]
+      def cardinality
+        @entity.count || super
+      end
+    end
+  end
+end

data/lib/nose/model.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'model/entity'
+require_relative 'model/fields'
+
+require 'graphviz'
+
+module NoSE
+  # A conceptual data model of a set of entities
+  class Model
+    # The subdirectory models are loaded from
+    LOAD_PATH = 'models'
+    include Loader
+
+    attr_reader :entities
+
+    def initialize(&block)
+      @entities = {}
+
+      # Apply the DSL
+      WorkloadDSL.new(self).instance_eval(&block) if block_given?
+    end
+
+    # Compare all entities
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Model) && @entities = other.entities
+    end
+    alias eql? ==
+
+    # Retrieve an entity by name
+    # @return [Entity]
+    def [](name)
+      return @entities[name] if @entities.key? name
+      fail EntityNotFound
+    end
+
+    # Add an {Entity} to the workload
+    # @return [Entity]
+    def add_entity(entity)
+      fail InvalidEntity, 'no primary key defined' if entity.id_field.nil?
+      @entities[entity.name] = entity
+    end
+
+    # Find a field given an +Enumerable+ of identifiers
+    # @return [Field]
+    def find_field(field)
+      if field.count > 2
+        find_field_chain field
+      else
+        find_entity_field(*field)
+      end
+    end
+
+    # Output a PNG representation of entities in the model
+    def output(format, filename, include_fields = false)
+      graph = GraphViz.new :G, type: :digraph
+      nodes = add_graph_nodes graph, include_fields
+      add_graph_edges graph, nodes
+
+      graph.output(**{ format => filename })
+    end
+
+    private
+
+    # Add the nodes (entities) to a GraphViz object
+    def add_graph_nodes(graph, include_fields)
+      Hash[@entities.each_value.map do |entity|
+        label = "#{entity.name}\n"
+        if include_fields
+          label += entity.fields.each_value.map do |field|
+            type = field.class.name.sub(/^NoSE::(.*?)(Field)?$/, '\1')
+            "#{field.name}: #{type}"
+          end.join("\n")
+        end
+
+        [entity.name, graph.add_nodes(label)]
+      end]
+    end
+
+    # Add the edges (foreign keys) to a GraphViz object
+    def add_graph_edges(graph, nodes)
+      @entities.each_value do |entity|
+        entity.foreign_keys.each_value do |key|
+          graph.add_edges nodes[entity.name], nodes[key.entity.name]
+        end
+      end
+    end
+
+    # Find a field in an entity where the entity may be a string or an object
+    def find_field_chain(field)
+      # Do a foreign key lookup
+      field = field.dup
+      key_field = @entities[field[0]][field[1]]
+      field[0..1] = key_field ? key_field.entity.name : field[1]
+      find_field field
+    end
+
+    # Find a field in an entity where the entity may be a string or an object
+    def find_entity_field(entity, field)
+      entity = entities[entity] if entity.is_a?(String)
+      entity[field]
+    end
+  end
+
+  # Raised when looking up an entity in the workload which does not exist
+  class EntityNotFound < StandardError
+  end
+
+  # Raised when attempting to add an invalid entity to a workload
+  class InvalidEntity < StandardError
+  end
+end

data/lib/nose/parser.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+# rubocop:disable Style/ClassAndModuleChildren
+
+# Parslet DSL extension for capturing the input source
+class CaptureSource < Parslet::Atoms::Capture
+  # Ugly hack to capture the source string that was parsed
+  def apply(source, context, consume_all)
+    before = source.instance_variable_get(:@str).rest
+    success, value = result = super(source, context, consume_all)
+    if success
+      # Save the portion of the source string
+      after = source.instance_variable_get(:@str).rest
+      source_str = before[0..(before.length - after.length - 1)]
+      value[(name.to_s + '_source').to_sym] = source_str
+    end
+
+    result
+  end
+end
+
+# Modify named captures to allow arrays
+class Parslet::Atoms::Named < Parslet::Atoms::Base
+  def initialize(parslet, name, array = false)
+    super()
+    @parslet = parslet
+    @name = name
+    @array = array
+  end
+
+  private
+
+  # Optionally wrap the produced single value in an array
+  def produce_return_value(val)
+    flatval = flatten(val, true)
+    flatval = [flatval] if @array && val.last == [:repetition]
+    { name => flatval }
+  end
+end
+
+# Extend the DSL to with some additional ways to capture the output
+module Parslet::Atoms::DSL
+  # Like #as, but ensures that the result is always an array
+  # @return [Array<Parslet::Atoms::Named>]
+  def as_array(name)
+    Parslet::Atoms::Named.new(self, name, true)
+  end
+
+  # Capture some output along with the source string
+  # @return [CaptureSource]
+  def capture_source(name)
+    CaptureSource.new(self, name)
+  end
+end
+
+# rubocop:enable Style/ClassAndModuleChildren
+
+module NoSE
+  # rubocop:disable Style/BlockEndNewline, Style/BlockDelimiters
+  # rubocop:disable Style/MultilineOperationIndentation
+
+  # Literals used in queries and updates
+  module Literals
+    include Parslet
+
+    rule(:integer)     { match('[0-9]').repeat(1).as(:int) }
+    rule(:quote)       { str('"') }
+    rule(:nonquote)    { quote.absent? >> any }
+    rule(:string)      { quote >> nonquote.repeat(1).as(:str) >> quote }
+    rule(:literal)     { integer | string | str('?').as(:unknown) }
+  end
+
+  # Predicates used in queries and updates
+  module Predicates
+    include Parslet
+
+    rule(:operator)    {
+      str('=') | str('!=') | str('<=') | str('>=') | str('<') | str('>') }
+    rule(:condition)   {
+      field.as(:field) >> space? >> operator.as(:op) >> space? >>
+      literal.as(:value) }
+    rule(:expression)  {
+      condition >> (space >> str('AND') >> space >> expression).repeat }
+    rule(:where)       {
+      space >> str('WHERE') >> space >> expression.as_array(:expression) }
+  end
+
+  # Identifiers and combinations of them used in queries and updates
+  module Identifiers
+    include Parslet
+
+    rule(:identifier)    { match('[A-z]').repeat(1).as(:identifier) }
+    rule(:field)         { identifier >> (str('.') >> identifier).repeat(1) }
+    rule(:fields)        { field >> (comma >> field).repeat }
+    rule(:select_field)  {
+      field.as_array(:field) | (identifier >> str('.') >>
+                                str('*').repeat(1, 2).as(:identifier2)) }
+    rule(:select_fields) { select_field >> (comma >> select_field).repeat }
+    rule(:path)          { identifier >> (str('.') >> identifier).repeat }
+  end
+
+  # Field settings for update and insert statements
+  module UpdateSettings
+    include Parslet
+
+    rule(:setting) {
+      (identifier | str('**')).as(:field) >> space? >> str('=') >> space? >>
+      literal.as(:value)
+    }
+    rule(:settings) {
+      setting >> (space? >> str(',') >> space? >> setting).repeat
+    }
+  end
+
+  # Parser for a simple CQL-like grammar
+  class CQLP < Parslet::Parser
+    include Literals
+    include Identifiers
+    include Predicates
+    include UpdateSettings
+
+    rule(:space)       { match('\s').repeat(1) }
+    rule(:space?)      { space.maybe }
+    rule(:comma)       { str(',') >> space? }
+
+    rule(:limit)       { space >> str('LIMIT') >> space >> integer.as(:limit) }
+    rule(:order)       {
+      space >> str('ORDER BY') >> space >> fields.as_array(:fields) }
+
+    rule(:comment)     { str(' -- ') >> match('.').repeat }
+
+    rule(:query) {
+      str('SELECT') >> space >> select_fields.as_array(:select) >>
+      space >> str('FROM') >> space >> path.as_array(:path) >>
+      where.maybe.as(:where) >> order.maybe.as(:order) >>
+      limit.maybe.capture(:limit) >> comment.maybe.as(:comment) }
+
+    rule(:update) {
+      str('UPDATE') >> space >> identifier.as(:entity) >> space >>
+      (str('FROM') >> space >> path.as_array(:path) >> space).maybe >>
+      str('SET') >> space >> settings.as_array(:settings) >>
+      where.maybe.as(:where).capture_source(:where) >>
+      comment.maybe.as(:comment)
+    }
+
+    rule(:connect_item) {
+      identifier.as(:target) >> space? >> str('(') >> space? >>
+      literal.as(:target_pk) >> space? >> str(')')
+    }
+
+    rule(:connect_list) {
+      connect_item >> (space? >> str(',') >> space? >> connect_item).repeat
+    }
+
+    rule(:insert) {
+      str('INSERT INTO') >> space >> identifier.as(:entity) >> space >>
+      str('SET') >> space >> settings.as_array(:settings) >>
+      (space >> str('AND') >> space >> str('CONNECT') >> space >>
+       str('TO') >> space >> connect_list.as_array(:connections)).maybe >>
+      comment.maybe.as(:comment)
+    }
+
+    rule(:delete) {
+      str('DELETE') >> space >> identifier.as(:entity) >>
+      (space >> str('FROM') >> space >> path.as_array(:path)).maybe >>
+      where.maybe.as(:where).capture_source(:where) >>
+      comment.maybe.as(:comment)
+    }
+
+    rule(:connect) {
+      (str('CONNECT') | str('DISCONNECT')).capture(:type) >> space >>
+      identifier.as(:entity) >> space? >> str('(') >> space? >>
+      literal.as(:source_pk) >> space? >> str(')') >> space >>
+      dynamic do |_, context|
+        context.captures[:type] == 'CONNECT' ? str('TO') : str('FROM')
+      end >> space >> connect_item
+    }
+
+    rule(:statement) {
+      query | update | insert | delete | connect
+    }
+
+    root :statement
+  end
+
+  # Simple transformations to clean up the CQL parse tree
+  class CQLT < Parslet::Transform
+    rule(identifier: simple(:identifier)) { identifier }
+    rule(identifier: simple(:identifier), identifier2: simple(:identifier2)) {
+      [identifier.to_s, identifier2.to_s] }
+    rule(field: sequence(:id)) { id.map(&:to_s) }
+    rule(path: sequence(:id)) { id.map(&:to_s) }
+    rule(str: simple(:string)) { string.to_s }
+    rule(statement: subtree(:stmt)) { stmt.first.last }
+    rule(int: simple(:integer)) { integer }
+    rule(unknown: simple(:val)) { nil }
+  end
+
+  # rubocop:enable all
+end