gold_mine 1.0.0

data/gold_mine.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "gold_mine/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "gold_mine"
+  spec.version       = GoldMine::VERSION
+  spec.authors       = ['Marcin "Archetylator" Syngajewski']
+  spec.email         = ["archetelecynacja@gmail.com"]
+  spec.summary       = %q{A simple, fortune cookie library for Ruby}
+  spec.homepage      = "http://github.com/Archetylator/goldmine"
+  spec.license       = "Beerware"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib", "fortunes"]
+
+  spec.add_dependency "bitswitch", "~> 1.1.4"
+
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "bundler", "~> 1.3"
+end

data/lib/gold_mine.rb

@@ -0,0 +1,18 @@
+# Loads gems
+%w{bitswitch pathname benchmark}.each { |x| require x }
+
+# Loads library files
+%w{db idb fortune index_reader index_writer version}.each do |x|
+  require_relative "gold_mine/#{x}"
+end
+
+module GoldMine
+  def self.base_dir
+    Pathname.new(File.expand_path("../../", __FILE__))
+  end
+
+  def self.default_db_path
+    base_dir.join("fortunes/fortunes").to_s
+  end
+end
+

data/lib/gold_mine/db.rb

@@ -0,0 +1,75 @@
+module GoldMine
+
+  # Database of fortunes.
+  #
+  # Example:
+  #   db = DB.new(path: "/home/user/fortunes")
+  #   db.random # => random fortune
+  #
+  # Options:
+  # [:+path+]
+  #   The path of database.
+  #
+  # [:+comments+]
+  #   Pass true if allow comments is needed.
+  #
+  # [:+delim+]
+  #   The character which is used as delimiter in a database.
+  #
+  class DB
+    def self.default_options
+      @default_options ||= {
+        delim: "%"
+      }
+    end
+
+    attr_reader :path, :options
+
+    def initialize(options = {})
+      @path = options.fetch(:path, GoldMine.default_db_path)
+      @options = self.class.default_options.merge(options)
+    end
+
+    def random
+      fortunes.sample
+    end
+
+    def fortunes
+      @fortunes ||= read_fortunes
+    end
+
+    private
+
+    def find_fortune(index)
+      read_fortunes(offset: index, size: 1).first
+    end
+
+    def read_fortunes(options = {})
+      offset = options.fetch(:offset, 0)
+      max_size = options.fetch(:size, Float::INFINITY)
+      fortunes, text = [], ""
+
+      File.open(@path, "r") do |file|
+        file.seek(offset)
+        file.each_line do |line|
+          break if fortunes.size == max_size
+
+          if @options[:comments]
+            next if line[/^#{@options[:delim]*2}/]
+          end
+
+          if line[/^#{@options[:delim]}/] || file.eof?
+            text << line if file.eof?
+            fortunes << Fortune.new(text) unless text.chomp.empty?
+            text.clear
+            next
+          end
+
+          text << line
+        end
+      end
+
+      fortunes
+    end
+  end
+end

data/lib/gold_mine/fortune.rb

@@ -0,0 +1,48 @@
+module GoldMine
+
+  # Represents a single fortune.
+  #
+  # First argument is an entire text of fortune.
+  # From that text a content and an attribution are extracted.
+  #
+  #   Fortune.new <<-EOF
+  #     "Calvin Coolidge looks as if he had been weaned on a pickle."
+  #             ― Alice Roosevelt Longworth
+  #   EOF
+  #
+  #   Returns a fortune where content attribute is equal to "Calvin Coolidge
+  #   looks as if he had been weaned on a pickle." and attribution attribute
+  #   is equal to "Alice Roosevelt Longworth".
+  #
+  class Fortune
+    ATTRB_RGXP = /^(\s*(―|--)|(―|--))\s*(?<attrb>.*)/
+
+    def initialize(content = "")
+      matches = content.match(ATTRB_RGXP)
+
+      @content = content.chomp.sub(ATTRB_RGXP, "")
+      @attribution = matches && matches[:attrb]
+    end
+
+    attr_accessor :content, :attribution
+
+    def to_s
+      if @content && !@content.empty? && @attribution
+        <<-FORMAT.gsub(/^ {10}/, "")
+
+          #{@content}
+                  ― #{@attribution}
+
+        FORMAT
+      elsif @content && !@content.empty? && !@attribution
+        <<-FORMAT.gsub(/^ {10}/, "")
+
+          #{@content}
+
+        FORMAT
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/gold_mine/idb.rb

@@ -0,0 +1,19 @@
+module GoldMine
+
+  # Database with a related index file.
+  #
+  class IDB < DB
+    attr_reader :index_reader
+
+    def initialize(options = {})
+      super
+
+      @index_reader = IndexReader.new("#{@path}.dat")
+      @options = @index_reader.options
+    end
+
+    def random
+      find_fortune(@index_reader.random_pointer)
+    end
+  end
+end

data/lib/gold_mine/index_reader.rb

@@ -0,0 +1,80 @@
+module GoldMine
+
+  # Reads an index for fortunes database. The index is a binary
+  # file which contains a header and pointers.
+  #
+  # The header stores statistical information and instruction
+  # specifying how to read the file. Pointer indicates an initial
+  # position for the related fortune.
+  #
+  class IndexReader
+    HEADER_SIZE  = 24
+    POINTER_SIZE = 4
+
+    def initialize(path)
+      @path = path
+
+      header = header_fields
+      @version = header[0]
+      @numstr = header[1]
+      @longlen = header[2]
+      @shortlen = header[3]
+      @flags = header[4].to_switch
+      @delim = header[5].chr
+    end
+
+    attr_reader :path, :numstr, :longlen, :shortlen, :version, :flags, :delim
+
+    # Returns a hash with selected header fields.
+    #
+    def options
+      {
+        version: @version,
+        delim: @delim,
+        randomized: @flags[0],
+        ordered: @flags[1],
+        rotated: @flags[2],
+        comments: @flags[3]
+      }
+    end
+
+    # Returns a header.
+    #
+    # The header consists of six 32-bit unsigned integers.
+    # Integers are stored in big-endian byte order.
+    #
+    # The order and meaning of the fields are as follows:
+    #
+    # [+version+] version number
+    # [+numstr+] number of pointers
+    # [+longlen+] size of longest fortune
+    # [+shortlen+] size of shortest fortune
+    # [+flags+] stores multiple booleans (bit-field)
+    #       [1] randomize order
+    #       [2] sorting in alphabetical order
+    #       [4] Caesar encryption
+    #       [8] allow comments
+    # [+delim+] 8-bit unsigned integer packed to 32-bit
+    #                which represents a delimeter character
+    #
+    def header_fields
+      IO.binread(@path, HEADER_SIZE, 0).unpack("N5C1")
+    end
+
+    # Returns all pointers.
+    #
+    def get_pointers
+      IO.binread(@path, @numstr * POINTER_SIZE, HEADER_SIZE).unpack("N*")
+    end
+
+    # Returns a pointer from a certain position.
+    #
+    def get_pointer_at(index)
+      IO.binread(@path, POINTER_SIZE, HEADER_SIZE + POINTER_SIZE * index).unpack("N").first
+    end
+
+    def random_pointer
+      get_pointer_at rand(@numstr)
+    end
+  end
+end

data/lib/gold_mine/index_writer.rb

@@ -0,0 +1,196 @@
+module GoldMine
+
+  # Creates a file which consists of a table describing
+  # the file, a table of pointers and an end of file position
+  # of related database. This file is called an index.
+  #
+  # The index allows fast access to fortunes.
+  # Provides additional info about a database e.g
+  # gives information if fortunes are ordered or encrypted.
+  #
+  # First argument is a path of fortune database.
+  # The second is an optional hash of options.
+  #
+  # Options:
+  # [:+index_path+]
+  #   The path under which the file will be saved.
+  #
+  # [:+version+]
+  #   The version of writer.
+  #
+  # [:+delim+]
+  #   The character which is used as delimiter in a database.
+  #
+  # [:+randomized+]
+  #   Passing true will shuffle pointers.
+  #
+  # [:+ordered+]
+  #   When enabled sorts pointers in an alphabetical order.
+  #
+  # [:+rotated+]
+  #   Pass true if pointers should be encrypted (Caesar cipher).
+  #
+  # [:+comments+]
+  #   If true allows comments in database.
+  #
+  class IndexWriter
+    def self.default_options
+      @default_options ||= {
+        version: 2,
+        delim: "%",
+        randomized: false,
+        ordered: false,
+        rotated: false,
+        comments: false
+      }
+    end
+
+    def initialize(path, options = {})
+      @path = path
+
+      options = self.class.default_options.merge(options)
+
+      @options = options
+      @longlen = 0
+      @numstr = 0
+      @eof = 0
+
+      # It's very important to keep it high.
+      # Otherwise in some cases shortest
+      # string will not be assigned.
+      #
+      @shortlen = 99999
+
+      @index_path = options[:index_path]
+      @version = options[:version]
+      @delim = options[:delim]
+
+      # An arrangement excludes a randomness.
+      #
+      options[:randomized] = false if options[:ordered]
+
+      @flags = BitSwitch.new({
+        randomized: options[:randomized],
+        ordered: options[:ordered],
+        rotated: options[:rotated],
+        comments: options[:comments]
+      })
+
+      @pointers = load_pointers
+      @numstr = @pointers.size
+
+      order_pointers! if @flags[:ordered]
+      shuffle_pointers! if @flags[:randomized]
+    end
+
+    attr_reader :version, :delim, :flags, :pointers, :longlen, :shortlen,
+                        :numstr
+
+    # When a path for index is not defined
+    # returns identical path to the database, but
+    # adds .dat extension at the end.
+    #
+    def index_path
+      @index_path || "#{@path}.dat"
+    end
+
+    def load_pointers
+      dregex = /^#{@delim}/
+      cregex = /^#{@delim*2}/
+      fregex = /[a-zA-Z0-9]/
+      pointers = []
+      length = 0
+      offset = 0
+      fchar = ""
+      new_string = true
+
+      File.open(@path) do |file|
+        file.each_with_index do |line, index|
+          if @flags[:comments]
+            next if line[cregex]
+          end
+
+          if new_string && !line[dregex]
+            fchar = line[fregex][0] if line[fregex]
+            offset = (file.pos - line.size)
+            new_string = false
+          end
+
+          if line[dregex] || file.eof?
+            if file.eof?
+              @eof = file.pos
+              length += line.size
+            end
+
+            unless length.zero?
+              pointers << [offset, fchar]
+
+              @longlen = length if length > @longlen
+              @shortlen = length if length < @shortlen
+
+              length = 0
+              new_string = true
+            end
+
+            next
+          end
+
+          length += line.size
+        end
+      end
+
+      pointers
+    end
+
+    def order_pointers!
+      @pointers.sort! { |x,y| [x[1], x[0]] <=> [y[1], y[0]] }
+    end
+
+    def shuffle_pointers!
+      @pointers = Hash[@pointers.to_a.shuffle]
+    end
+
+    def write
+      File.write(index_path, packed_header << packed_pointers << packed_eof)
+    end
+
+    # Returns an array of pointers.
+    #
+    # @pointers is an array where each element
+    # is an array. The array contains an offset at first
+    # and a first character of fortune as second.
+    # Described method extracts offsets.
+    #
+    def offsets
+      @pointers.map { |p| p.first }
+    end
+
+    # Packs the pointers as 32-bit unsigned
+    # integers in big-endian byte order.
+    #
+    def packed_pointers
+      offsets.pack("N*")
+    end
+
+    # Packs a database end of file position as 32-bit
+    # unsigned integer in big-endian byte order.
+    #
+    def packed_eof
+      [@eof].pack("N")
+    end
+
+    # Packs the header fields as 32-bit unsigned
+    # unsigned integers in big-endian byte order.
+    #
+    def packed_header
+      [
+        @version,
+        @numstr,
+        @longlen,
+        @shortlen,
+        @flags.to_i,
+        @delim.ord << 24 # bitpacked to 32-bit integer
+      ].pack("N6")
+    end
+  end
+end