enf 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e55d0099cadb7696261d7142c429fab7af91d4a
+  data.tar.gz: 85fd5160859456781784d49ceed188f4b26ed9f0
+SHA512:
+  metadata.gz: 679913e249b668fa54d3da5303a9acb87aaa2e7444c9beaf50c0b35ea4f599b02e428caab10b548d56c0edd393b9901b195f85832f84de12333c975f24255ee0
+  data.tar.gz: fe80390060f3cb8d6af9b843a116780bf8f996bb2f7bc01283d736db29eb37acfe6fc74b0eb684ea32e2c473b0ffe37ce5ce097acd596150a0b428d5397d0f63

data/Gemfile.lock

@@ -0,0 +1,56 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.0.0)
+    astrolabe (1.3.0)
+      parser (>= 2.2.0.pre.3, < 3.0)
+    benchmark-ips (2.1.1)
+    byebug (4.0.5)
+      columnize (= 0.9.0)
+    coderay (1.1.0)
+    columnize (0.9.0)
+    diff-lcs (1.2.5)
+    memory_profiler (0.9.4)
+    method_source (0.8.2)
+    parser (2.2.2.5)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.1.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.1.0)
+      byebug (~> 4.0)
+      pry (~> 0.10)
+    rainbow (2.0.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    rubocop (0.32.1)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.2.5, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    ruby-progressbar (1.7.5)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  benchmark-ips
+  memory_profiler
+  pry-byebug
+  rspec (~> 3.3)
+  rubocop

data/README.md

@@ -0,0 +1,112 @@
+# Elephants never forget !
+
+Memory lightweight implementation of a white/black list
+
+## Examples
+
+*Building a dictionnary of all terms used in 'Les misérables'*
+
+```ruby
+require 'open-uri'
+URI = 'https://www.gutenberg.org/ebooks/135.txt.utf-8'
+
+elephant = Enf::Elephant.new
+
+open(URI) do |file|
+  file.read.scan(/[[:alpha:]]*/).each do |token|
+    elephant.register! token.downcase
+  end
+end
+
+elephant.include? 'bonjour'
+# => true
+
+elephant.include? 'megadrive'
+# => false
+
+```
+
+*Building a shared blacklist with a rack app*
+
+```ruby
+require 'rack'
+require 'enf'
+require 'JSON'
+
+elephant = Enf::Elephant.new
+
+app = Proc.new do |env|
+  puts env.inspect
+  path = env.fetch('PATH_INFO')
+  case path 
+  when '/'
+    ['200', {'Content-Type' => 'text/html'}, ['A sample elephant black list rack app']]
+  when /^\/add\//
+    elephant.register!(token = path[5..-1])
+    ['200', {'Content-Type' => 'text/html'}, ["Registered '#{token}'"]]
+  when /^\/know\//
+    result = elephant.include?(token = path[6..-1])
+    ['200', {'Content-Type' => 'text/json'}, [{ token => result }.to_json]]
+  else
+    ['404', {'Content-Type' => 'text/html'}, ['Learn to talk elephantish']]
+  end
+end
+ 
+Rack::Handler::WEBrick.run app
+```
+
+
+
+## Note on implementation
+
+Instead of storing all listed values like follow:
+```ruby
+  {
+    "foo"     => true,
+    "bar"     => true,
+    "foobar"  => true,
+    # ...
+    "foobob"  => true
+  }
+```
+
+Those are stored in several nested hashes like follow:
+
+```ruby
+  {
+    "f" => {
+      "o" => {
+        "o" => {        # leave
+          "b" => {
+            "a" => "r", # leave
+            "o" => "b"  # leave
+          }
+        }
+      }
+    },
+    "b" => {
+      "a" => "r"        # leave
+    }
+  }
+```
+
+Avoiding duplication of factorizable content.
+
+## Note on performances
+
+Enf::Elephant being sensibly slower than using sets or hashes on small
+volume of data, it is recommended to use it when memory matters most and
+when words are easily factorizable (example : as a black list for twitter
+spam bots).
+
+## Next ?
+
+I will probably be working on:
+
+1. Single path merging: Now, when a single word uses a specific path
+(example: bar, in the previous example), a hash is created for every
+letter of that specific path. We have to merge theim as a single element
+to avoid useless hash creation.
+2. Completion: With that data structure, it will be quite easy and
+efficient to propose completion candidates from a start of word.
+3. tbd

data/enf.gemspec

@@ -0,0 +1,26 @@
+# encoding: utf-8
+#
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'enf/version'
+Gem::Specification.new do |s|
+  s.name = 'enf'
+  s.version = Enf::Version::STRING
+  s.summary = 'Elephants never forget'
+  s.description = 'Graph based white/black list implementation. Your elephant won\'t forget.'
+  s.authors = ['Alexandre Ignjatovic']
+  s.email = 'alexandre.ignjatovic@gmail.com'
+  s.files = `git ls-files`.split($RS).reject do |file|
+    file =~ %r{^(?:
+    spec/.*
+    |.*\.swp
+    |Gemfile
+    |Rakefile
+    |\.rspec
+    |\.gitignore
+    |\.rubocop.yml
+    )$}x
+  end
+  s.require_paths = ['lib']
+  s.homepage = 'https://github.com/bankair/enf'
+  s.license = 'MIT'
+end

data/lib/enf/elephant.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Enf
+  # Represent a node of the graph
+  class Elephant
+    class CannotRegister < RuntimeError; end
+    def initialize(default_leave_value = false)
+      @default_leave_value = default_leave_value
+      @leave = default_leave_value
+      @children = Hash.new { |hash, key| hash[key] = Elephant.new }
+    end
+
+    def register!(element, payload = true)
+      fail CannotRegister if frozen? || invalid?(element)
+      return (@leave = payload) if element.empty?
+      @children[element[0]].register!(element[1..-1])
+    end
+
+    # Null node, used to answer to unknown values
+    class Nope
+      require 'singleton'
+      include Singleton
+
+      def include_impl(_)
+        false
+      end
+
+      def register!(_)
+        fail CannotRegister
+      end
+    end
+
+    def include?(element)
+      return @default_leave_value if invalid?(element)
+      include_impl element
+    end
+
+    def include_impl(element)
+      return @leave if element.empty?
+      @children.fetch(element[0]) { Nope.instance }.include_impl(element[1..-1])
+    end
+
+    protected
+
+    require 'set'
+
+    AUTHORIZED_TYPES = Set.new([String, Array]).freeze
+
+    def invalid?(element)
+      return true if element.nil?
+      return true unless AUTHORIZED_TYPES.include? element.class
+      false
+    end
+  end
+end

data/lib/enf/version.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Enf
+  # This module holds the Enf version information.
+  module Version
+    STRING = '0.0.0'
+
+    module_function
+
+    def version(_debug = false)
+      STRING
+    end
+  end
+end

data/lib/enf.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require 'enf/version'
+require 'enf/elephant'

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: enf
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Alexandre Ignjatovic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-15 00:00:00.000000000 Z
+dependencies: []
+description: Graph based white/black list implementation. Your elephant won't forget.
+email: alexandre.ignjatovic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile.lock
+- README.md
+- enf.gemspec
+- lib/enf.rb
+- lib/enf/elephant.rb
+- lib/enf/version.rb
+homepage: https://github.com/bankair/enf
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Elephants never forget
+test_files: []
+has_rdoc: