mementus 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a03cb6779f6872174442d561581c14c8048597c7
-  data.tar.gz: e0b0e81f172b9b699a94a2da9ca65da1899823ee
+  metadata.gz: 2ae7a8b89d3a35849ea26912ff75d5b2491e7c87
+  data.tar.gz: 0d4bdcb9bede0c28548e2f1565126864e98683ff
 SHA512:
-  metadata.gz: 5c45ef7529f95d104b97a4e92dd7ee0b922250f689e63f713f2b05c3794811cac69abb5b2d6b78c41cb058cf943a508c99d7af30eac6f65e84f82abe7b1c4992
-  data.tar.gz: 8e62108ba5e92626ffea76a45d1222e7fe4c6cd3769e3af6ebf66b182d37d73d49ea67ef0d6bd4c9b9c22f98bd5ddade73e836bbd062a0d79fef072e96cbb481
+  metadata.gz: 8eff9fc722af1259cd66415632281d52f5e237da5f9914b05416d5ae6f84e662290a2072674f5d2a659de6f297d45c1539c4000eea2327ae6dd4dfb4d2616384
+  data.tar.gz: cffc400f5e932176b9dcd8a0bc06d0506964ed8a2268acc818205b6c82bf9fb761997c85711e28600e85d954b6521d1eeac6c552a03882be0dee26607882369b

data/README.md

@@ -1,99 +1,3 @@
 # Mementus
 
 [![Build Status](https://travis-ci.org/maetl/mementus.svg?branch=master)](https://travis-ci.org/maetl/mementus)
-
-Mementus is a transient ORM for creating and querying in-memory object models.
-
-## Installation
-
-Add this line to your application's Gemfile and `bundle` or `bundle update`:
-
-    gem 'mementus'
-
-Or install with your local Rubygems:
-
-    $ gem install mementus
-
-## Usage
-
-### Defining model classes
-
-To define model classes, inherit from the `Mementus::Model` base class and add attributes using the [Virtus API](https://github.com/solnic/virtus):
-
-```ruby
-class Book < Mementus::Model
-  attribute :title, String
-  attribute :author, String
-end
-```
-
-### Creating objects
-
-Create new instances by passing data through the constructor or assigning attributes directly:
-
-```ruby
-book1 = Book.new(
-  :title => "Gravity's Rainbow",
-  :author => "Thomas Pynchon"
-)
-
-book2 = Book.new
-book2.title = "The Golden Notebook"
-book2.author = "Doris Lessing"
-```
-
-To write objects to the in-memory index, call their `create` method:
-
-```ruby
-book3 = Book.new(
-  :title => "Crash",
-  :author => "J.G. Ballard"
-)
-
-book3.create
-```
-
-### Matching queries
-
-Basic match queries can be constructed by passing a predicate hash to the `where` method:
-
-```ruby
-Book.where(author: "Doris Lessing")
-
-Book.where(title: "Crash")
-```
-
-### Scoped queries
-
-Reusable query shortcuts can be constructed on the model class by defining a `scope`:
-
-```ruby
-class Book < Mementus::Model
-  attribute :title, String
-  attribute :author, String
-  attribute :genre, String
-  scope :scifi, genre: 'scifi'
-  scope :romance, genre: 'romance'
-end 
-```
-
-These defined scopes become class methods on the model:
-
-```ruby
-scifi_books = Book.scifi
-romance_books = Book.romance
-```
-
-## Roadmap
-
-- 0.2: Query API
-- 0.3: Relationships API
-- 0.4: Value objects
-
-## Contributing
-
-1. Fork it
-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 new Pull Request

data/lib/mementus/edge_builder.rb

@@ -0,0 +1,39 @@
+module Mementus
+  class EdgeBuilder
+    attr_reader :from, :to, :label
+
+    def initialize(from=nil, to=nil, label=:edge)
+      @from = from
+      @to = to
+      @label = label
+    end
+
+    def from=(node, label=:node)
+      if node.is_a?(Node)
+        @from = node
+      else
+        @from = Node.new(node, label)
+      end
+    end
+
+    def to=(node)
+      if node.is_a?(Node)
+        @to = node
+      else
+        @to = Node.new(node, label)
+      end
+    end
+
+    def label=(label)
+      @label = label
+    end
+
+    def nodes
+      [@from, @to]
+    end
+
+    def other(node)
+      @from == node ? @to : @from
+    end
+  end
+end

data/lib/mementus/graph.rb

@@ -2,8 +2,12 @@ require 'set'
 
 module Mementus
   class Graph
-    def initialize(is_directed=true)
-      @structure = Structure.new(is_directed)
+    def initialize(is_directed=true, &block)
+      builder = GraphBuilder.new(is_directed)
+
+      builder.instance_eval(&block) if block_given?
+
+      @structure = builder.graph
     end
 
     def query
@@ -22,22 +26,6 @@ module Mementus
       @structure.directed?
     end
 
-    def add_node(node)
-      @structure.add_node(node)
-    end
-
-    def create_edge(&block)
-      @structure.create_edge(&block)
-    end
-
-    def create_node(&block)
-      @structure.create_node(&block)
-    end
-
-    def add_edge(edge)
-      @structure.add_edge(edge)
-    end
-
     def has_node?(node)
       @structure.has_node?(node)
     end

data/lib/mementus/graph_builder.rb

@@ -0,0 +1,27 @@
+module Mementus
+  class GraphBuilder
+    def initialize(is_directed)
+      @structure = Structure.new(is_directed)
+    end
+
+    def add_node(node)
+      @structure.add_node(node)
+    end
+
+    def create_edge(&block)
+      @structure.create_edge(&block)
+    end
+
+    def create_node(&block)
+      @structure.create_node(&block)
+    end
+
+    def add_edge(edge)
+      @structure.add_edge(edge)
+    end
+
+    def graph
+      @structure
+    end
+  end
+end

data/lib/mementus/integer_id.rb

@@ -0,0 +1,18 @@
+require 'thread'
+
+module Mementus
+  class IntegerId
+    def initialize(start_value=1)
+      @current_value = start_value
+      @mutex = Mutex.new
+    end
+
+    def next_id
+      @mutex.lock
+      allocated = @current_value
+      @current_value += 1
+      @mutex.unlock
+      allocated
+    end
+  end
+end

data/lib/mementus/node_builder.rb

@@ -0,0 +1,18 @@
+module Mementus
+  class NodeBuilder
+    attr_reader :id, :label
+
+    def initialize(id=nil, label=:node)
+      @id = id
+      @label = label
+    end
+
+    def id=(id)
+      @id = id
+    end
+
+    def label=(label)
+      @label = label
+    end
+  end
+end

data/lib/mementus/structure.rb

@@ -1,6 +1,6 @@
 module Mementus
   class Structure
-    def initialize(is_directed)
+    def initialize(is_directed=true)
       @index = {}
       @is_directed = is_directed
     end
@@ -36,8 +36,8 @@ module Mementus
     end
 
     def add_edge(edge)
-      add_node(edge.from)
-      add_node(edge.to)
+      add_node(edge.from) unless has_node?(edge.from)
+      add_node(edge.to) unless has_node?(edge.to)
 
       @index[edge.from].add(edge.to)
       @index[edge.to].add(edge.from) unless directed?

data/lib/mementus/version.rb

@@ -1,3 +1,3 @@
 module Mementus
-  VERSION = '0.2.6'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/lib/mementus.rb

@@ -9,3 +9,7 @@ require_relative 'mementus/query/traversal'
 require_relative 'mementus/query/source'
 require_relative 'mementus/query/step'
 require_relative 'mementus/query/traversal'
+require_relative 'mementus/integer_id'
+require_relative 'mementus/graph_builder'
+require_relative 'mementus/node_builder'
+require_relative 'mementus/edge_builder'

data/spec/graph_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe Mementus::Graph do
+  let(:graph) do
+
+  end
+
   specify '#new' do
     graph = Mementus::Graph.new
 
@@ -9,18 +13,20 @@ describe Mementus::Graph do
   end
 
   specify '#add_node' do
-    graph = Mementus::Graph.new
-    graph.add_node(Mementus::Node.new(1, :node))
+    graph = Mementus::Graph.new do
+      add_node(Mementus::Node.new(1, :node))
+    end
 
     expect(graph.nodes_count).to eq(1)
     expect(graph.edges_count).to eq(0)
   end
 
   specify '#create_node' do
-    graph = Mementus::Graph.new
-    graph.create_node do |node|
-      node.id = 1
-      node.label = :vertex
+    graph = Mementus::Graph.new do
+      create_node do |node|
+        node.id = 1
+        node.label = :vertex
+      end
     end
 
     expect(graph.nodes_count).to eq(1)
@@ -28,19 +34,21 @@ describe Mementus::Graph do
   end
 
   specify '#add_edge' do
-    graph = Mementus::Graph.new
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node)))
+    graph = Mementus::Graph.new do
+      add_edge(Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node)))
+    end
 
     expect(graph.nodes_count).to eq(2)
     expect(graph.edges_count).to eq(1)
   end
 
   specify '#create_edge' do
-    graph = Mementus::Graph.new
-    graph.create_edge do |edge|
-      edge.label = :relationship
-      edge.from = "A"
-      edge.to = "B"
+    graph = Mementus::Graph.new do
+      create_edge do |edge|
+        edge.label = :relationship
+        edge.from = "A"
+        edge.to = "B"
+      end
     end
 
     expect(graph.nodes_count).to eq(2)
@@ -48,36 +56,41 @@ describe Mementus::Graph do
   end
 
   specify '#has_node?' do
-    graph = Mementus::Graph.new
     node = Mementus::Node.new(1, :node)
-    graph.add_node(node)
+    graph = Mementus::Graph.new do
+      add_node(node)
+    end
 
     expect(graph.has_node?(node)).to be true
     expect(graph.has_node?(node.dup)).to be false
   end
 
   specify '#has_edge?' do
-    graph = Mementus::Graph.new
     edge = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
     edge2 = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
-    graph.add_edge(edge)
+
+    graph = Mementus::Graph.new do
+      add_edge(edge)
+    end
 
     expect(graph.has_edge?(edge)).to be true
     expect(graph.has_edge?(edge2)).to be false
   end
 
   specify '#node(id)' do
-    graph = Mementus::Graph.new
     edge = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
-    graph.add_edge(edge)
+    graph = Mementus::Graph.new do
+      add_edge(edge)
+    end
 
     expect(graph.node(1)).to eq(edge.from)
   end
 
   specify '#nodes(filter)' do
-    graph = Mementus::Graph.new
     edge = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
-    graph.add_edge(edge)
+    graph = Mementus::Graph.new do
+      add_edge(edge)
+    end
 
     expect(graph.nodes).to eq([edge.from, edge.to])
   end

data/spec/integer_id_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Mementus::IntegerId do
+  it 'counts upwards from 1 by default' do
+    generator = Mementus::IntegerId.new
+    expect(generator.next_id).to eq(1)
+    expect(generator.next_id).to eq(2)
+    expect(generator.next_id).to eq(3)
+  end
+
+  it 'counts upwards from given start value' do
+    generator = Mementus::IntegerId.new(100)
+    expect(generator.next_id).to eq(100)
+    expect(generator.next_id).to eq(101)
+    expect(generator.next_id).to eq(102)
+  end
+end

data/spec/node_proxy_spec.rb

@@ -2,12 +2,13 @@ require 'spec_helper'
 
 describe Mementus::NodeProxy do
   specify '#new' do
-    graph = Mementus::Graph.new
     node1 = Mementus::Node.new(1, :node)
     node2 = Mementus::Node.new(2, :node)
     node3 = Mementus::Node.new(3, :node)
-    graph.add_edge(Mementus::Edge.new(node1, node2))
-    graph.add_edge(Mementus::Edge.new(node1, node3))
+    graph = Mementus::Graph.new do
+      add_edge(Mementus::Edge.new(node1, node2))
+      add_edge(Mementus::Edge.new(node1, node3))
+    end
 
     node_proxy = Mementus::NodeProxy.new(node1, graph)
     expect(node_proxy.adjacent.map { |node| node.id}).to eq([node2.id, node3.id])

data/spec/query_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe Mementus::Query do
   let(:graph) do
-    graph = Mementus::Graph.new
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node)))
-    graph
+    Mementus::Graph.new do
+      add_edge(Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node)))
+    end
   end
 
   specify '#node' do

data/spec/spec_helper.rb

@@ -1,6 +1,2 @@
 require 'rspec'
 require 'mementus'
-
-RSpec.configure do |config|
-  config.formatter = 'documentation'
-end

data/spec/structure_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Mementus::Structure do
+  let(:structure) do
+    Mementus::Structure.new
+  end
+
+  specify '#new' do
+    expect(structure.nodes_count).to eq(0)
+    expect(structure.edges_count).to eq(0)
+  end
+
+  specify '#add_node' do
+    structure.add_node(Mementus::Node.new(1, :node))
+
+    expect(structure.nodes_count).to eq(1)
+    expect(structure.edges_count).to eq(0)
+  end
+
+  specify '#create_node' do
+    structure.create_node do |node|
+      node.id = 1
+      node.label = :vertex
+    end
+
+    expect(structure.nodes_count).to eq(1)
+    expect(structure.edges_count).to eq(0)
+  end
+
+  specify '#add_edge' do
+    structure.add_edge(Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node)))
+
+    expect(structure.nodes_count).to eq(2)
+    expect(structure.edges_count).to eq(1)
+  end
+
+  specify '#create_edge' do
+    structure.create_edge do |edge|
+      edge.label = :relationship
+      edge.from = "A"
+      edge.to = "B"
+    end
+
+    expect(structure.nodes_count).to eq(2)
+    expect(structure.edges_count).to eq(1)
+  end
+
+  specify '#has_node?' do
+    node = Mementus::Node.new(1, :node)
+    structure.add_node(node)
+
+    expect(structure.has_node?(node)).to be true
+    expect(structure.has_node?(node.dup)).to be false
+  end
+
+  specify '#has_edge?' do
+    edge = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
+    edge2 = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
+    structure.add_edge(edge)
+
+    expect(structure.has_edge?(edge)).to be true
+    expect(structure.has_edge?(edge2)).to be false
+  end
+
+  specify '#node(id)' do
+    edge = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
+    structure.add_edge(edge)
+
+    expect(structure.node(1)).to eq(edge.from)
+  end
+
+  specify '#nodes(filter)' do
+    edge = Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(2, :node))
+    structure.add_edge(edge)
+
+    expect(structure.nodes).to eq([edge.from, edge.to])
+  end
+end

data/spec/traversal_spec.rb

@@ -6,15 +6,16 @@ describe 'Basic graph traversals' do
   end
 
   let(:graph) do
-    graph = Mementus::Graph.new
-    graph.add_edge(Mementus::Edge.new(start, Mementus::Node.new(2, :node)))
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(2, :node), Mementus::Node.new(3, :node)))
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(2, :node), Mementus::Node.new(5, :node)))
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(6, :node)))
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(2, :node), Mementus::Node.new(7, :node)))
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(7, :node), Mementus::Node.new(8, :node)))
-    graph.add_edge(Mementus::Edge.new(Mementus::Node.new(5, :node), Mementus::Node.new(9, :node)))
-    graph
+    start_node = start
+    graph = Mementus::Graph.new do
+      add_edge(Mementus::Edge.new(start_node, Mementus::Node.new(2, :node)))
+      add_edge(Mementus::Edge.new(Mementus::Node.new(2, :node), Mementus::Node.new(3, :node)))
+      add_edge(Mementus::Edge.new(Mementus::Node.new(2, :node), Mementus::Node.new(5, :node)))
+      add_edge(Mementus::Edge.new(Mementus::Node.new(1, :node), Mementus::Node.new(6, :node)))
+      add_edge(Mementus::Edge.new(Mementus::Node.new(2, :node), Mementus::Node.new(7, :node)))
+      add_edge(Mementus::Edge.new(Mementus::Node.new(7, :node), Mementus::Node.new(8, :node)))
+      add_edge(Mementus::Edge.new(Mementus::Node.new(5, :node), Mementus::Node.new(9, :node)))
+    end
   end
 
   specify 'DepthFirstSearch#each' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mementus
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - maetl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-30 00:00:00.000000000 Z
+date: 2016-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,20 +69,25 @@ files:
 - lib/mementus/breadth_first_search.rb
 - lib/mementus/depth_first_search.rb
 - lib/mementus/edge.rb
+- lib/mementus/edge_builder.rb
 - lib/mementus/graph.rb
+- lib/mementus/graph_builder.rb
+- lib/mementus/integer_id.rb
 - lib/mementus/node.rb
+- lib/mementus/node_builder.rb
 - lib/mementus/node_proxy.rb
 - lib/mementus/query/source.rb
 - lib/mementus/query/step.rb
 - lib/mementus/query/traversal.rb
-- lib/mementus/relation.rb
 - lib/mementus/structure.rb
 - lib/mementus/version.rb
 - mementus.gemspec
 - spec/graph_spec.rb
+- spec/integer_id_spec.rb
 - spec/node_proxy_spec.rb
 - spec/query_spec.rb
 - spec/spec_helper.rb
+- spec/structure_spec.rb
 - spec/traversal_spec.rb
 homepage: https://github.com/maetl/mementus
 licenses:
@@ -104,14 +109,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: In-memory data model
 test_files:
 - spec/graph_spec.rb
+- spec/integer_id_spec.rb
 - spec/node_proxy_spec.rb
 - spec/query_spec.rb
 - spec/spec_helper.rb
+- spec/structure_spec.rb
 - spec/traversal_spec.rb
-has_rdoc: 

data/lib/mementus/relation.rb

@@ -1,68 +0,0 @@
-module Mementus
-  module Relation
-    module ClassMethods
-
-      def where(constraints)
-        Query.new(self.collection, self.cache).where(constraints)
-      end
-
-      def all
-        Query.new(self.collection, self.cache).objects
-      end
-
-      def order(constraints)
-        Query.new(self.collection, self.cache).order(constraints)
-      end
-
-    end
-
-    # Chainable query object that delegates to the given relation.
-    class Query
-
-      def initialize(relation, cache)
-        @relation = relation
-        @cache = cache
-      end
-
-      # Filters the collection based on the given constraints.
-      #
-      # - Pass in a key-value hash to filter based on matching attributes by equality.
-      # - Pass in a block to construct a more specialised predicate match.
-      def where(constraints)
-        Query.new(@relation.restrict(constraints), @cache)
-      end
-
-      # Order the collection by attribute and direction
-      def order(constraints)
-        ordered_relation = @relation.sort_by do |relation|
-          constraints.keys.inject([]) do |list, constraint|
-            direction = constraints[constraint].to_sym
-            direction = :asc unless direction == :desc
-            list << relation.send(constraint.to_sym).send(direction)
-          end
-        end
-        Query.new(ordered_relation, @cache)
-      end
-
-      # Materializes the relation to an array of model objects.
-      def objects
-        @relation.inject([]) do |list, relation|
-          list << @cache[relation[:__cache_key]]
-        end
-      end
-
-      # Enumerate over each object.
-      def each(&block)
-        @relation.each do |relation|
-          yield block
-        end
-      end
-
-      # Number of objects.
-      def count
-        objects.count
-      end
-
-    end
-  end
-end