anagram_solver 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b09baa79e607ae059995e5c52012c5dfe875bbe
+  data.tar.gz: 52002f88f8736f79bf36e1f027739575b7d84bfe
+SHA512:
+  metadata.gz: 6ec1715650407f74c4c6efb772b3b05a698c78d6b8c9d2fa5d0f8c9ab5c450dd1ba87e8bc4e942215a53020da1e7205c7fb2a7f5dabc24c3df89e2196a4afd62
+  data.tar.gz: 0cd752f03c338f83ae92df5cd5203239a435b2aca2a13908cabdeac493fa320e77c5fa5de2adfd91f99128fa21a31850872b4df021e8a33cc33720e7071072c2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= AnagramSolver
+
+A Ruby gem for that plugs into Rails.
+The gem allows for the upload of a text file which will be
+the dictionary file.  The dictionary file consists of a
+list of words. Each word is on separate line.
+The gem provides an input where a user can input a word of their
+choice. On hitting enter (or clicking a button) the webapp should find all
+anagrams, if any exist, of the word and display them. If no anagrams are
+found it should display “No anagrams found for <word>”.
+
+= TODO
+
+Create an Instrumentation to save searched anagrams.
+Save tempfile into root_path/public/uploads, and keep
+track of them, so that it can be displayed as a list
+and a user can select that particular word list to use it.
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AnagramSolver'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/anagram_solver/application.js

@@ -0,0 +1,17 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+
+//= require jquery
+//= require jquery_ujs
+//= require turbolinks
+//= require_tree .

data/app/assets/javascripts/anagram_solver/index.js

@@ -0,0 +1,65 @@
+$(function(){
+
+  $("#search_area").hide();
+  $('#word').attr('autocomplete','off');
+
+  $.extend({
+    ajaxPostRequest: function(url, formData, callBack){
+      $.ajax({
+        url: url,
+        type: "POST",
+        data: formData,
+        async: false,
+        success: callBack,
+        contentType: false,
+        cache: false,
+        processData: false
+      });
+    },
+    ajaxGetRequest: function(url, jsonData, callBack){
+      $.ajax({
+        url: url,
+        type: "POST",
+        data: JSON.stringify(jsonData),
+        async: false,
+        success: callBack,
+        contentType: "application/json; charset=utf-8",
+        traditional: true,
+        cache: false,
+        processData: false
+      });
+    }
+
+  });
+
+  $("body").on("submit","form#new_anagram", function(e){
+    var formData = new FormData($(this)[0]);
+    var url = $(this).attr("action");
+
+    $.ajaxPostRequest(url, formData, function(data){
+      $(".loaded_in").html(data + "ms");
+      $("#search_area").fadeIn();
+      $("#word").focus();
+    });
+
+    $("#results").html("");
+    e.preventDefault();
+  });
+
+
+  $("body").on("submit","form#search", function(e){
+
+    var url   = "/search";
+    var word  = { word: $("#word").val() }
+    $("#word").val("");
+
+    $.ajaxGetRequest(url, word, function(d){
+      var result =  "<div class='results'><span>"+d.started_at+"</span>"+
+                    "<span>"+d.notice+"</span>"+
+                    "<span>>"+d.anagrams+"</span></div>"
+      $("#results").prepend(result);
+    });
+    e.preventDefault();
+  });
+
+});

data/app/assets/stylesheets/anagram_solver/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/assets/stylesheets/anagram_solver/index.css

@@ -0,0 +1,38 @@
+body{
+  margin: 0;
+}
+
+.results {
+  width: 500px;
+  margin: 5px;
+  display: table;
+  background: black;
+  margin-bottom: 10px;
+  border: white dotted 2px;
+}
+
+span {
+  float: left;
+  width: 100%;
+  margin-bottom: 2px;
+  background: white;
+}
+
+#word {
+  border: solid 1px black;
+  outline: 0;
+  width: 20%;
+  margin: 7px;
+  padding-left: 5px;
+}
+
+#dict {
+  float: left;
+}
+
+.loaded_in {
+  float: left;
+  width: 100px;
+  height: 20px;
+  line-height: 20px;
+}

data/app/controllers/anagram_solver/anagram_solver_controller.rb

@@ -0,0 +1,16 @@
+module AnagramSolver
+  class AnagramSolverController < ApplicationController
+
+    respond_to :html, :json
+
+    def index
+    end
+
+    def create
+      respond_to do |f|
+        f.json { render json: Time.now.strftime("%2N").to_json, status: 200 }
+      end
+    end
+
+  end
+end

data/app/controllers/anagram_solver/application_controller.rb

@@ -0,0 +1,4 @@
+module AnagramSolver
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/anagram_solver/application_helper.rb

@@ -0,0 +1,4 @@
+module AnagramSolver
+  module ApplicationHelper
+  end
+end

data/app/models/anagram_solver/anagram.rb

@@ -0,0 +1,9 @@
+module AnagramSolver
+  class Anagram
+    include Mongoid::Document
+
+    field :searched_at, type: Date
+    field :finished_at, type: Date
+    field :dictionary_name, type: String
+  end
+end

data/app/views/anagram_solver/anagram_solver/_form.html.erb

@@ -0,0 +1,16 @@
+<%= form_tag "/anagram_solver", id: :new_anagram, method: :post, multipart: true do %>
+  <%= file_field_tag :dict %><span class="loaded_in"></span>
+  <div class="actions">
+    <%= submit_tag "Load new dictionary" %>
+  </div>
+<% end %>
+
+<div id="search_area">
+  <%= form_tag "/search", method: :get, id: :search do %>
+    <%= text_field_tag :word %>
+    <%= submit_tag :find %>
+  <% end %>
+</div>
+
+<div id="results">
+</div>

data/app/views/anagram_solver/anagram_solver/index.html.erb

@@ -0,0 +1 @@
+<%= render("anagram_solver/anagram_solver/form") %>

data/app/views/layouts/anagram_solver/application.html.erb

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>AnagramSolver</title>
+  <%= stylesheet_link_tag    "anagram_solver/application", media: "all" %>
+  <%= javascript_include_tag "anagram_solver/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+<%= yield %>
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,5 @@
+AnagramSolver::Engine.routes.draw do
+  root "anagram_solver#index"
+
+  resource :anagram_solver, controller: :anagram_solver
+end

data/lib/anagram_solver.rb

@@ -0,0 +1,4 @@
+require "anagram_solver/loader"
+
+module AnagramSolver
+end

data/lib/anagram_solver/async_consumer.rb

@@ -0,0 +1,96 @@
+module AnagramSolver
+  class AsyncConsumer
+
+    ##
+    # TODO: remove this
+    #
+    class << self
+      attr_reader :thread
+
+      def bg_process(to_be_processed, &block)
+        @thread = Thread.new(to_be_processed) { |p|
+          block.call(p)
+        }
+      end
+
+      def wait
+        thread.join
+      end
+    end
+
+    attr_reader :queue, :thread
+    attr_reader :block, :mutex
+
+    def initialize(queue=Queue.new, &block)
+      @queue  = queue
+      @thread = Thread.new { consume }
+      @mutex  = Mutex.new
+      @block  = block
+      @lock   = true
+    end
+
+    ##
+    # Consumes data from a queue.
+    # NOTE: If I was to use a while loop
+    # here, I'd have to find a way of stoping
+    # the loop. A common way would be pushing
+    # nil to queue and then it would exit.
+    # However I'd have to be passing nil ATFT.
+    # If I didn't pass nil it would raise:
+    #   Failure/Error:
+    #   (anonymous error class);
+    #   No live threads left. Deadlock?
+    # As there's nothing in queue.
+    #
+    # In Ruby you have a lot of different ways
+    # to make the same thing.
+    #
+    # This implentation simply asks queue what it's
+    # size is and then loops through it (i.e times)
+    # and then I call queue.deq which stands for
+    # deqeuing.
+    #
+    def consume
+      (queue.size).times do
+        mutex.synchronize {
+          block.call(queue.deq)
+          @lock = true
+        }
+      end
+    end
+
+    ##
+    # Pushes args in to a queue.
+    #
+    def push(*args)
+      queue.push(*args)
+      mutex.synchronize { @lock = false }
+    end
+
+    ##
+    # Waits for a thread to finish
+    # returns nil if limit seconds have past.
+    # or returns thread itself if thread was
+    # finished  whithing limit seconds.
+    #
+    # If you call it without a limit second,
+    # it will use 0 as default, therefore it
+    # will not wait thread to finish, and it
+    # will return nil.
+    # (i.e Stops main thread ( current one )
+    # and waits until the other thread is finished,
+    # then passes execution to main thread again. )
+    #
+    def wait_thread_to_finish!(ttw=0)
+      thread.join(ttw)
+    end
+
+    def finished?
+      lock
+    end
+
+    private
+      attr_reader :lock
+
+  end
+end

data/lib/anagram_solver/engine.rb

@@ -0,0 +1,10 @@
+module AnagramSolver
+  class Engine < ::Rails::Engine
+    isolate_namespace AnagramSolver
+
+    initializer "anagram_solver.add_middleware" do |app|
+      app.middleware.insert_after ::Rack::Runtime, AnagramSolver::Middleware
+    end
+
+  end
+end

data/lib/anagram_solver/file_manager.rb

@@ -0,0 +1,97 @@
+##
+# Responsability
+# Read lines from a file
+# Create a new file, absolute path should be passed in.
+# Check file exists?
+# Manage a File object
+#
+# TODO:
+# Make it compartible with File object
+# As it is only compartible with Tempfile
+#
+module AnagramSolver
+  class FileManager
+    attr_reader :current_file, :root_path
+
+    ##
+    # current_file is a temp_file to read
+    # content from it and be destroyed later on when
+    # everything gets garbaged.
+    #
+    # root_path is the path to save new files.
+    #
+    # TODO:
+    # Make it work with instances of File,
+    # as it only works with Tempfile.
+    #
+    def initialize(current_file)
+      @current_file = current_file
+      @root_path    = AnagramSolver::RootPath
+    end
+
+    def read_lines
+      open_safely! { |f| f.rewind; f.read }
+    end
+
+    ##
+    # Returns file's root path
+    #
+    def current_file_path
+      current_file.to_path
+    end
+
+    ##
+    # Creates a new file, saves it based on
+    # root_path provided.
+    # NOTE: Ruby File#open when called with a block closes
+    # file stream for us.
+    # This is not compartible with Ruby 1.8.7.
+    #
+    def new_file(new_name=false, body)
+      f_name = new_name || file_name_with_path
+      File.open(f_name, "w") { |line|
+        line.write(body)
+        line
+      }
+    end
+
+    ##
+    # Checks file existence using current_file_path.
+    # However if absolute path is passed in, uses this
+    # over current_file_path.
+    #
+    def file_exist?(_file_name_=false)
+      File.exists?(_file_name_ || current_file_path)
+    end
+
+
+    private
+
+      ##
+      # Keeps a tmp_file opened for the
+      # duration of a block call.
+      #
+      def open_safely!
+        yield current_file.open
+        ensure
+        current_file.close
+      end
+
+      ##
+      # Creates a root_path with file name at the end.
+      #
+      def file_name_with_path
+        root_path.dup + file_name
+      end
+
+      ##
+      # Returns its random file name that TempFile
+      # assings when new object is created.
+      # test_file_name434302324843493
+      #
+      def file_name
+        "/" + current_file.path.split('/').pop
+      end
+
+  end
+end

data/lib/anagram_solver/finder.rb

@@ -0,0 +1,95 @@
+require 'json'
+##
+# TODO:
+# This object is doing too much
+# Perhaps we need to break it into
+# smaller objects.
+#
+module AnagramSolver
+  class Finder
+
+    class << self
+
+      include ActionView::Helpers::TextHelper
+
+      attr_accessor :finished_at, :started_at
+      attr_accessor :time, :word, :anagrams
+      @finished_at  = ""
+      @started_at   = ""
+      @time         = ""
+      @word         = ""
+      @anagrams     = ""
+
+      ##
+      # Finds anagrams for a given key ( i.e word )
+      # and a list, which should be already precomputed.
+      # It returns a JSON object, see anagrams_found!.
+      #
+      def find_for(key, list)
+        timer { look_up(list, key) }
+        anagrams_found!
+      end
+
+      ##
+      # Look for anagrams
+      #
+      def look_up(list, _word_)
+        @word       = _word_
+        key         = list.sort!(word)
+        @anagrams   = list.precomputed_list[key]
+      end
+
+      private
+
+      ##
+      # Generates a JSON object
+      # with results of finished_at, started_at,
+      # milliseconds, and anagrams found.
+      def anagrams_found!
+        {
+          notice: "#{pluralize(size, "anagram")} found for '#{word}' in #{time}",
+          anagrams: join_anagrams_found!,
+          finished_at: normalize_time!(finished_at),
+          started_at: normalize_time!(started_at)
+        }.to_json
+      end
+
+      def size
+        anagrams.size
+      end
+
+      def join_anagrams_found!
+        anagrams.join(", ")
+      end
+
+      ##
+      # Simple timer to get started/finished time/date
+      # and to generate milliseconds
+      #
+      def timer
+        self.started_at   = Time.now
+          result = yield
+        self.finished_at  = Time.now
+          result
+        self.time = (self.finished_at - self.started_at) * 1000
+      end
+
+      ##
+      # Normalizes time as 10/25/2013 at 04:15 PM
+      #
+      def normalize_time!(_time_)
+        _time_.strftime("%m/%d/%Y at %I:%M %p")
+      end
+
+      ##
+      # Get milliseconds.
+      #
+      def milliseconds
+        finished_at.strftime("%N").to_i - started_at.strftime("%N").to_i
+      end
+
+    end
+
+
+  end
+end

data/lib/anagram_solver/loader.rb

@@ -0,0 +1,7 @@
+require 'anagram_solver/routing'
+require 'anagram_solver/finder'
+require 'anagram_solver/permutator'
+require 'anagram_solver/file_manager'
+require 'anagram_solver/async_consumer'
+require 'anagram_solver/middleware'
+require 'anagram_solver/engine'

data/lib/anagram_solver/middleware.rb

@@ -0,0 +1,110 @@
+require 'rack/request'
+
+##
+# TODO:
+# Break this down, as it is doing
+# alot.
+module AnagramSolver
+  class Middleware
+    attr_reader :app, :precomputed
+
+    def initialize(app)
+      @app          = app
+      @precomputed  = ""
+      @env          = ""
+    end
+
+    ##
+    # Assigns env to @env to be used later on.
+    # If PATH_INFO matches search, it then tries
+    # to find anagrams. In not it goes down the stack.
+    #
+    def call(env)
+      @env = env
+      uploaded_tempfile?
+      search? || app.call(env)
+    end
+
+    ##
+    # Returns a response which is a JSON response
+    # if search_path?
+    #
+    # When trying to find an anagram AnagramSolver::Finder
+    # returns either anagrams found for a particular word or
+    # it returns a notice (i.e a message ) saying that No anagrams
+    # was found for that particular word.
+    #
+    def search?
+      return response if search_path?
+    end
+
+    private
+
+      attr_reader :env
+
+      ##
+      # True is PATH_INFO matches search,
+      # false otherwise.
+      #
+      def search_path?
+        env["PATH_INFO"] == "/search"
+      end
+
+      ##
+      # Sets a 200 HTTP response code,
+      # Sets Content-Type to JSON, and
+      # returns anagrams_result.
+      #
+      def response
+        response = anagrams_result
+        [200, { "Content-Type" => "application/json" }, [response]]
+      end
+
+
+      ##
+      # Returns results of anagrams.
+      # If none is found it returns a notice
+      # saying that no anagram was found.
+      #
+      def anagrams_result
+        Finder.find_for(word, @precomputed)
+      end
+
+
+      ##
+      # Gets the json request sent to server
+      # then parse it and get the raw word.
+      #
+      def word
+        word = JSON.parse(env["rack.input"].string)
+        word["word"]
+      end
+
+
+      ##
+      # Rack::Request rocks!!
+      #
+      def params
+        Rack::Request.new(env)
+      end
+
+      ##
+      # Gets the tempfile uploaded.
+      # Rack::Request parses and extract params
+      # from StringIO for us.
+      #
+      def tempfile
+        params["dict"][:tempfile]
+      end
+
+      def uploaded_tempfile?
+        precompute! if env["PATH_INFO"] == "/anagram_solver"
+      end
+
+
+      def precompute!
+        @precomputed = Permutator.new(tempfile)
+      end
+
+  end
+end

data/lib/anagram_solver/permutator.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+##
+# Responsability
+# Create a hash of precomputed anagrams
+# to facilitate when searching for one.
+# Rather than doing all the possible combinations
+# at run time.
+#
+# Here's a benchmark with, unpack and chars
+#
+# require 'benchmark'
+#
+# Benchmark.bm do |bm|
+#   bm.report("Unpack") do
+#     1000_000.times do
+#       "aabcjksjdsodoiio32j3k2jkjdksjkdsj,, ,fd,f,d, f,d,,---".gsub(/[,\t\r\n\f]*/, "").unpack("c*").sort.pack("c*")
+#     end
+#   end
+#
+#   bm.report("Chars") do
+#     1000_000.times do
+#       "aabcjksjdsodoiio32j3k2jkjdksjkdsj,, ,fd,f,d, f,d,,---".gsub(/[,\t\r\n\f]*/, "").chars.sort.join
+#     end
+#   end
+# end
+#
+# user     system      total        real
+# Unpack 37.620000   0.080000  37.700000 ( 37.781407)
+# Chars 65.020000   0.200000  65.220000 ( 65.300449)
+#
+
+module AnagramSolver
+  require 'anagram_solver/async_consumer'
+  class Permutator
+
+    attr_reader :word_list, :precomputed_list
+    attr_reader :precomputed_list_old, :bg_process
+
+    ##
+    # Initializes word_list instance variable, precomputed_list
+    # assigning it a hash whose default values is an empty array.
+    #
+    # Precomputes word_list in underneath the hood. (i.e A in-process
+    # thread that AsyncConsumer offers. )
+    #
+    def initialize(word_list)
+      @word_list        = word_list
+      @precomputed_list = Hash.new([])
+      @bg_process       = AsyncConsumer.bg_process(self) { |s| s.precompute }
+      @precomputed_list_old = Hash.new([])
+    end
+
+    ##
+    # Used for benchmarking
+    #
+    def precompute_old
+      warn "This method should not be used, please use precompute instead."
+      word_list.rewind.each do |line|
+        word = line.chomp
+        precomputed_list_old[word.split('').sort.join.freeze] += [word]
+      end
+    end
+
+    ##
+    # Generates a hash whose keys are sorted
+    # alphabetically and values (i.e rhd ) are words
+    # in its normal order.
+    #
+    # Given a list pots, stop, opts
+    # When I precompute it
+    # Then I should have a hash like:
+    # { "opst" => [ "pots", "stop", "opts" ] }
+    #
+    # NOTE:
+    # precompute only gets the first word it 'slices' off
+    # a line. Therefore if a line was:
+    # "pots, opts"
+    # It would get the first word, which is +pots+.
+    #
+    # However if it was:
+    # ", Deviation's, pots";
+    # It would slice Deviation's
+    #
+    # It is also slices words with accents, such as:
+    # émigré's
+    # Ångström
+    #
+    # If you're on UNIX-like there might exist a dict
+    # word in see /usr/share/dict/words
+    #
+    # Want to learn more about Regexp?
+    # Fear not:
+    # open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1500.html
+    #
+    def precompute
+      word_list.each do |line|
+        # word = line.chomp.slice(/\b['\wÀ-ÖÙ-Üà-öù-ü]+/i)
+        word = line.chomp
+        precomputed_list[sort!(word)] += [word]
+      end
+    end
+
+    ##
+    # Orders any given word in alphabetical order by
+    # unpacking them (i.e spliting ) sort and packing
+    # them again ( i.e joining ).
+    # This facilitates when trying to find combinations
+    # for words, as we only have to sort once
+    # and return results by calling a hash with a sorted key.
+    #
+    # ruby-doc.org/core-2.0.0/Array.html#method-i-pack
+    # See: en.wikipedia.org/wiki/UTF-8
+    # Unpacks a string using:
+    # Integer UTF-8 character, as it can represent
+    # every character in the Unicode char set.
+    # Such as émigré's
+    # * means all remaining arrays elements will be
+    # converted.
+    #
+    # Freezes string, otherwise Ruby would generate
+    # another String object instead of keeping
+    # the one already supplied. So that we would have
+    # two instances of the same thing in memory.
+    #
+    def sort!(word)
+      word.unpack("U*").sort.pack("U*").freeze
+    end
+
+  end
+end

data/lib/anagram_solver/routing.rb

@@ -0,0 +1,18 @@
+##
+# Responsability
+# Add anagram_solver as root_path
+#
+# TODO:
+# Allow anagram_solver to be mounted
+# at a different path.
+module AnagramSolver
+  module Routing
+    extend ActiveSupport::Concern 
+    def anagram_to_root_path!
+      mount(AnagramSolver::Engine, at: "/")
+    end
+
+  end
+end
+
+ActionDispatch::Routing::Mapper.send(:include, AnagramSolver::Routing)

data/lib/anagram_solver/version.rb

@@ -0,0 +1,3 @@
+module AnagramSolver
+  VERSION = "0.0.2"
+end

data/lib/tasks/anagram_solver_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :anagram_solver do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: anagram_solver
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Antonio C Nalesso Moreira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Reads a dictionary file and allows a user to find anagrams.
+email:
+- acnalesso@yahoo.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/views/anagram_solver/anagram_solver/index.html.erb
+- app/views/anagram_solver/anagram_solver/_form.html.erb
+- app/views/layouts/anagram_solver/application.html.erb
+- app/helpers/anagram_solver/application_helper.rb
+- app/assets/javascripts/anagram_solver/index.js
+- app/assets/javascripts/anagram_solver/application.js
+- app/assets/stylesheets/anagram_solver/index.css
+- app/assets/stylesheets/anagram_solver/application.css
+- app/controllers/anagram_solver/application_controller.rb
+- app/controllers/anagram_solver/anagram_solver_controller.rb
+- app/models/anagram_solver/anagram.rb
+- config/routes.rb
+- lib/tasks/anagram_solver_tasks.rake
+- lib/anagram_solver/routing.rb
+- lib/anagram_solver/version.rb
+- lib/anagram_solver/permutator.rb
+- lib/anagram_solver/file_manager.rb
+- lib/anagram_solver/loader.rb
+- lib/anagram_solver/finder.rb
+- lib/anagram_solver/middleware.rb
+- lib/anagram_solver/engine.rb
+- lib/anagram_solver/async_consumer.rb
+- lib/anagram_solver.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+homepage: https://www.github.com/acnalesso/anagram_solver
+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.5
+signing_key: 
+specification_version: 4
+summary: Finds anagrams for a given word.
+test_files: []