session = Neon::Session::Rest.new(url, options)

options = {
       directory: '', # Prefix the url with this directory
          cypher: '/cypher', # Cypher path for the server
         gremlin: '/ext/GremlinPlugin/graphdb/execute_script', # Gremlin path for the server
             log: false, # Log activity or not
        log_path: 'neon.log', # File name used for the log if :log is true
         threads: 20, # Maximum number of threads to use
  authentication: nil,  # 'basic' or 'digest'
        username: nil,
        password: nil,
          parser: MultiJsonParser
}

session = Neon::Session::Rest.new("http://username:password@localhost:7474/mydirectory")

session = Neon::Session::Embedded.new(path_to_db, auto_tx)

Neon::Session.current
# Set another session to be current. You get a boolean on whether it was successful or not
Neon::Session.set_current another_session # Returns true or false
# You can also do this
Neon::Session.current = another_session
another_session.current? # Check if this session is the current session or not?

# Creating a session does not start it. You can start the session as follows
started? = session.start

# Close a session
closed? = session.close

# Check if a session has been started i.e. is it running?
running? = session.running?

# All instance method calls are also available on Session and are called on the current session e.g.
started? = Neon::Session.start
close? = Neon::Session.close
running? = Neon::Session.running? # and others

# Location of the database
session.location

session.auto_tx # Defaults to true
session.auto_tx = false
Neon::Session.auto_tx = false # Disable auto transaction on the current session

# ================================================================
# Property Container
# These methods are available on Neon::Node and Neon::Relationship
# with the same signature and behaviour.
# ================================================================

# Get a container's session
session = container.session

# Get a single key
value = container[:key] # Returns the value

# Get one or more properties
value1, value2 = container[:key1, :key2]
values = container[:key1, :key2] # Returns an array on a query of multiple propeties

# Non existing properties return nil
value = container[:invalid_key]
value, nil_value = container[:key, :invalid_key]
# The last argument can be a hash. If it is provided then you can specify a default value
# instead of nil for non exisitng keys.
value, hello_world = container[:key, :invalid_key] default: 'hello world'

# Set one or more properties
container[:key1, :key2] = value1, value2
container[:key1, :key2] = values # an array

container[:invalid_key] = value # Creates a key :invalid_key and sets it to value
container[nil] = value # Calls #to_s on every key. If multiple properties resolve to same name
# then the last value
# is used.

container[valid_key] = invalid_value # anything besides String, Symbol, Numeric, true, false or an
#array of these (all objects of the same type) is going to throw an exception InvalidValueError.
# There is an exception to this where setting a key to nil deletes it. Setting a non existing
# key to nil does nothing.

# Get all keys
keys = container.keys

# Check if a key exists
container.key?('a key') # Returns true or false on the basis of wether 'a key' exists or not

# Create a new node
node = Neon::Node.new(attributes, label1, label2, session)

# Empty node in the current session
node = Neon::Node.new

# A node with attributes in the current session and no labels
node = Neon::Node.new(name: :name, email: :email)

# A node with attributes in the given session
node = Neon::Node.new({name: :name}, another_session)

# A node with attributes and labels in the current session
node = Neon::Node.new({name: :name, sex: 'male'}, :User, :Man)
node = Neon::Node.new({name: :name, sex: 'male'}, [:User, :Man])

# A node with attributes and labels in the given session
node = Neon::Node.new({name: :name, sex: 'male'}, :User, :Man, another_session)
node = Neon::Node.new({name: :name, sex: 'male'}, [:User, :Man], another_session)

# An empty node in the given session
node = Neon::Node.new another_session

# A node with labels in the current session
node = Neon::Node.new(:User)
node = Neon::Node.new([:User])

# A node with labels in the given session
node = Neon::Node.new(:User, another_session)
node = Neon::Node.new([:User], another_session)

# Returns the load with id 5
node = Neon::Node.load(5)
same_node = Neon::Node.load(node.id)
invalid_node = Neon::Node.load(:non_existent_id)

# Get a node's id
id = node.id

# ==============
# Node methods
# ==============

# Get all labels of a node
node.labels # => ['label', 'User', 'Programmer']

# Add one or more labels
# Labels can be anything that responds to #to_s
node.add_labels(:runner, :biker)
node.add_labels([:runner, biker])

# Remove one or more labels
node.remove_labels(:runner, :biker)
node.remove_labels([:runner, :biker])

# Check if a node has a label
node.label?(:Runner) # => returns true or false

# Create a relationship to another node
node.create_rel_to(another_node, :RELATIONSHIP_TYPE)
# If both node and another_node do not have the same database location then it throws a CrossSessionError

# Get all relationships
node.rels

# Get all relationships in a particular direction
node.rels(dir: :incoming)
node.rels(dir: :outgoing)

# Get relationships to nodes with particular labels
node.rels(labels: [:friend, :jusband])

# Get relationships of a particular type by passing a options hash with type key. 
# It can be anything that responds to #to_s
# Both directions
node.rels(type: relationship_type) # a variable that responds to #to_s. The response to #to_s is used
node.rels(type: [:relationship_type, :another_relationship_type])
# Get relationships between two nodes
node.rels(between: another_node)
# You can mix and match various options to create filters.

# Get a single relationship if it exists or nil
node.rel(dir: :incoming, type: [:RELATIONSHIP_TYPE, :ANOTHER_RELATIONSHIP_TYPE])

# Check if a node has a particular relationship
node.rel? # Any relationships?
node.rel?(dir: :incoming) or node.rel?(dir: :outgoing) # Any incoming or outgoing relationships
node.rel?(type: :RELATIONSHIP_TYPE) # => true or false
node.rel?(dir: :incoming, type: :RELATIONSHIP_TYPE) # => true or false

# Delete a node its relationships
# Raises exception if there are relationships.
node.delete # => return true or false if node was deleted

# Delete a node and it's relationships.
node.delete! # => return true or false if node was destroyed or not

# Get the nodes
start_node, end_node = rel.nodes # => A 2 element array

# Get start node
rel.start

# Get end node
rel.end

# Get the other node or nil if the supplied node is not part of the relationship
rel.other(node)

# Get the type of a node. This is a object that responds to #to_s
rel.type

# Check if the relationship is of a particular type. Type can be anything that responds to #to_s
rel.type?(a_type)

# Begin a transaction. If a transaction is already on then it is returned.
# Run them in a begin-rescue block since they might throw an exception
tx = session.begin_tx
begin
  # Do some graph operations
  tx.failure # mark transaction for failure. Marked by default
rescue Exception => e
  # handle execption
else
  tx.success # mark transaction for success if no exception occured
ensure
  tx.close # commit or rollback on the basis of wether tx was marked for success or failure
end

# Run a quick transaction. This fires a new transaction in a new thread.
# t is the transaction. You can call success or failure on it. Don't call close as it will throw
# an exception later. An optional session can be passed to run the transaction on. Defaults to current session.
Transaction.run(optional_session) do |t|
  # Do some graph operations.
  # If you do something here that does not pertain to the session that t belongs to then it will
  # not be a part of the transaction
end

# t is marked for success by default. This allows you run quick one method calls like
# The result of the block is returned.
result = Transaction.run { do_something_graphy }

# An array of indexes
indexes = Neon::Node.indexes

index_exists? = Neon::Node.index?("User")

# Default type is exact and provider is lucene
index = Neon::Node.create_index("User", :exact, :lucene)

# Exact match
hits = user_index.get(key, value) # hits is an enumerable

# Get a single node if it exists or nil
 node_or_nil = hits.single

# Use lucene queries
hits = user_index.query(key, query)

hits = user_index.query(query)

user_index.add(node, :email, node[:email])

# Remove a node from user index for the given key-value pair
user_index.remove(node, :email, node[:email])

# Remove a node from user index for the given key
user_index.remove(node, :email)

# Remove a node from user index
user_index.remove(node)

user_index.delete

# Get the score(number of hits) of the most recently fetched node
sore = hits.score

# Get the auto index
auto_index = Neon::Node.index

# Enable the auto_index
auto_index.status = true

# Disable the auto_index
auto_index.status = false

# Add a property to the auto index
auto_index.add_property(property)

# Remove a property to the auto index
auto_index.remove_property(property)

# Get nodes with a key-value pair
hits = auto_index.get(key, value)

# Query nodes
hits = auto_index.query(query)

Neon::Node.create_index_on(:Person, property1, property2)

# options is a hash of key-value pairs. All nodes matching all values for the given keys are returned.
hits = Neon::Node.index_for(:Person, options)

Neon::Node.delete_index_on(:Person, property1, propert2)

# constraint is :unique by default and as not other contraint is supported right now
# we do not take a contraint argument. This makes our api backwards compatible
Neon::Node.create_contraint_on(:Person, property1, property2)

Neon::Node.drop_contraint_on(:Person, property1, propert2)

# arguments are the same as Neon::Node.new
unique_ndoe = Neon::Node.uniq(arguments)