connie 0.0.1

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+
+gem 'rspec', '>= 2.0.0.beta.20', :group => :test

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 ilpoldo
+
+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,68 @@
+= Connie
+==== Little compact library to synthesise data that does not load big files in memory.
+
+Heavily based on Forgery[http://github.com/sevenwire/forgery.git] it uses the same word sources. It's built to be a bit more customisable and allows you to define new strategies and styles both using ruby modules or big text lists.
+
+== Install
+
+On the console:
+    >> gem install connie
+    
+In your Gemfile
+    gem 'connie'
+
+== Usage
+
+Connie offers four exciting functionalities:
+  
+* Dictionaries
+* Shorthand to pick a random element from an array
+* Interpolating strings
+
+===Dictionaries
+
+A dictionary is a vast source of words for a subject, Connie has 4 dictionaries built in:
+
+* Names
+* Geo
+* Net
+* Creative
+* Shopping
+
+For example inspecting the names dictionary:
+    Connie[:names].inspect # Shorthand to access a dictionary
+    <Connie::Dictionary - Connie::Names - company last female suffix title male first gender>
+You receive a quick overview of what this dictionary can generate. To have the dictionary generate something simply:
+    Connie[:names].first
+
+== Extending
+You can extend Dictionaries in two ways:
+
+* Providing word list files either by putting the _word_name_ file into the _dictionary_name_ folder in a folder registered with connie
+* Anywhere in your code by adding instance methods to the Connie::_DictionaryName_ module
+
+The first way will ensure that calling the word type a line is randomly picked from the list; the second is useful to aggregate different words from the lists and present the in different ways:
+
+    # e.g. Extending the names dictionary to return a full name
+    module Connie
+      module Names
+        # Returns a full name
+        def full
+          "#{first} #{last}"
+        end    
+      end
+    end
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Leandro Pedroni. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "connie"
+    gem.summary = %Q{Little compact library to synthesise data that does not load big files in memory}
+    gem.description = %Q{Heavily based on Forgery it uses the same word sources. It's built to be a bit more customisable and allows you to define new strategies and styles both using ruby modules or big text lists.}
+    gem.email = "ilpoldo@gmail.com"
+    gem.homepage = "http://github.com/ilpoldo@gmail.com/connie"
+    gem.authors = ["Leandro Pedroni"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "connie #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/connie/connie.rb

@@ -0,0 +1,54 @@
+module Connie
+  
+  class DictionaryNotFound < StandardError; end
+  class DictionaryNameNotAllowed < StandardError; end
+  
+  @dictionaries = {}
+  @alphabet = %w(a A b B c C d D e E f F g G h H i I j J k K l L m M n N o O p P q Q r R s S t T u U v V w W x X y Y z Z)
+  
+  def self.dictionaries_paths;@dictionaries_paths;end
+  def self.dictionaries;@dictionaries;end
+  
+  def self.[] dictionary_name
+    @dictionaries[dictionary_name.to_sym] or Dictionary.new(dictionary_name.to_s)
+  end
+  
+  def self.register_dictionary(dictionary)
+    @dictionaries[dictionary.name.to_sym] = dictionary
+  end
+  
+  # Picks a random line from a text file
+  def self.pick_a_line_from(file_path)
+    File.open file_path, 'r' do |file|
+      file.inject { |choice, line| rand < 1/file.lineno.to_f ? line.gsub(%r{\s$},'') : choice }
+    end
+  end
+  
+  def self.reload_dictionaries
+    @dictionaries = {}
+  end
+  
+  # Returns a random letter
+  def self.letter(variant=nil)
+    index = rand(26)*2
+    index +=1 if variant == :uppercase
+    @alphabet[index]
+  end
+  
+  def self.digit
+    rand(9)
+  end
+  
+  def self.formats format, min = 1, max = 0
+    array = max > 0 ? Array.new(rand(max-min)+min) : Array.new(min)
+      
+    generator = case format
+    when :W then lambda {Connie.letter(:uppercase)}
+    when :w then lambda {Connie.letter}
+    when :d then lambda {Connie.digit.to_s}
+    end
+    
+    array.map{generator.call}.join
+  end
+  
+end

data/lib/connie/dictionary.rb

@@ -0,0 +1,65 @@
+module Connie
+  class Dictionary
+    
+    attr_accessor :name, :module_name
+    
+    def initialize(dictionary_name)
+      @name = dictionary_name
+      @module_name = dictionary_name.gsub(%r{(?:^|_)([a-z])?}) { $1.upcase }
+      
+      #TODO: Check the format of the dictionary name
+      raise DictionaryNameNotAllowed if %w(Dictionary Parser).include? @module_name      
+      
+      load_dictionary_files_and_modules
+      
+      Connie.register_dictionary self
+    end
+    
+    def inspect
+      from_the_module = Connie.const_defined?(@module_name) ? Connie.const_get(@module_name).instance_methods : []
+
+      all_the_methods = @word_lists.keys.concat from_the_module
+      
+      "#{}<#{self.class} - Connie::#{@module_name} - #{all_the_methods.join(' ')}>"
+    end
+    
+    def interpolate string
+      Connie::Parser.process string, self
+    end
+    
+    alias :i :interpolate
+    
+    def load_dictionary_files_and_modules
+      @word_lists = []
+      
+      Connie.dictionaries_paths.each do |dictionaries_path|
+        @word_lists.concat Dir[File.join dictionaries_path, @name, '*']
+        @word_lists.concat Dir[File.join(dictionaries_path, "#{@name}.*")]
+      end
+
+      # Indexes the dictionary files into an array
+      @word_lists = @word_lists.inject({}) {|a,f| a[f.split(%r{[./]}).last.to_sym]=f; a}
+      
+      @word_lists.delete :rb
+      
+      # Defines methods based on word lists
+      @word_lists.keys.each do |list|
+        instance_eval <<-LIST
+        def #{list} options={}
+          interpolate Connie.pick_a_line_from @word_lists[:#{list}]
+        end
+        LIST
+      end
+      
+      # Find and load modules
+      modules = []
+      Connie.dictionaries_paths.each do |dictionaries_path|
+        modules.concat Dir[File.join dictionaries_path, "#{@name}.rb"]
+      end
+      modules.each {|m| require m}
+      
+      extend Connie.const_get(@module_name) if Connie.const_defined?(@module_name)
+    end
+          
+  end
+end

data/lib/connie/generators.rb

@@ -0,0 +1,9 @@
+module Connie
+
+  if defined? Rails && (Rails.version.to_f >= 3.0)
+    class DictionaryGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+    end
+  end
+  
+end

data/lib/connie/parser.rb

@@ -0,0 +1,64 @@
+module Connie
+  class Parser
+    
+    #TODO: implement negative lookahead to allow escaping \: and escaping the escaping symbol itself \\
+    attr_accessor :dictionary
+    
+    @syntax = {# :method or :dictionary.method
+               %r{((?:[\\]+)?\:\w\w+(?:.\w+)?)} => lambda do |dictionary_and_method|
+                arguments = dictionary_and_method[1..-1].split('.').map &:to_sym
+                case arguments.size
+                when 2 then Connie[arguments[0]].send arguments[1]
+                when 1 then dictionary.send arguments[0]
+                end
+               end,
+               # :d - one digit
+               %r{((?:[\\]+)?\:[wWd])(?:[^\w\{])} => lambda do |letter_or_digit|
+                Connie.formats letter_or_digit[1].to_sym
+               end,
+               # :w{2,4} - two to four letters
+               %r{((?:[\\]+)?\:[wWd](?:\{\d+(?:,\d+)?\}))} => lambda do |character_and_frequency|
+                character, f_min, f_max = character_and_frequency[1..-1].match(%r{(\w)(?:\{(\d+)(?:,(\d+))?\})})[1..-1]
+                Connie.formats character.to_sym, f_min.to_i, f_max.to_i
+               end
+               
+              }
+        
+    def self.process string_to_parse, dictionary = Connie[:names]
+      tokenized = string_to_parse.split Regexp.union(@syntax.keys)
+            
+      Connie::Parser.new(dictionary).apply_syntax(tokenized).join
+    end
+    
+    def initialize(dictionary)
+      @dictionary = dictionary
+    end
+    
+    # calls trasform on the tokens marked for interpolation and deals with escaping
+    def apply_syntax tokens
+      tokens.map do |t|
+        if t[0] && t[0].chr == ':'
+          transform t
+        elsif t[0] && t[0].chr == '\\' # some level of escaping is present
+          raise 'I don\' speak escapeese yet!'
+        else
+          t
+        end
+      end
+    end
+    
+    # Interpolates a syntax token
+    def transform string
+      result = nil
+      syntax.each_pair { |k,func| result = instance_exec(string, &func) if string.match(k) }
+      return result
+    end
+    
+  private
+    
+    def syntax
+      @rebound_syntax ||= self.class.instance_variable_get('@syntax')
+    end
+    
+  end
+end

data/lib/connie.rb

@@ -0,0 +1,59 @@
+require 'connie/connie'
+require 'connie/dictionary'
+require 'connie/parser'
+
+
+module Connie
+  # class Railtie < Rails::Railtie
+  #   config.tabelle = ActiveSupport::OrderedOptions.new
+  # 
+  #   initializer "tabelle.tabelle" do |app|
+  #     ActiveSupport.on_load(:action_view) do
+  #       include Tabelle::Helper
+  #     end
+  # 
+  #     ActiveSupport.on_load(:action_controller) do
+  #       include Tabelle::Controller
+  #       append_view_path File.expand_path('views',File.dirname(__FILE__))
+  #     end
+  #   end
+  # 
+  # end
+  @dictionaries_paths = [File.expand_path('dictionaries',File.dirname(__FILE__))]
+  VERSION = File.exist?('VERSION') ? File.read('VERSION') : ""
+end
+
+# The shorthand method to use connie
+# Accepts three kinds of arguments:
+# 
+# 1) String
+#    Connie parses the string replacing the :dictionary.format bits of string with random
+#    results from it's dictionaries
+# 
+# 2) Symbols
+#    Uses the symbol to pick the dictionary to return and eventually calls the format on 
+#    it.
+# 
+# 3) Arrays
+#    As a form of convenience Connie picks a random element out of the array passed
+#
+def Connie(argument, options={})
+  case argument
+  when String
+    Connie::Parser.process(argument)
+  when Symbol
+    argument = argument.to_s.split('.').map &:to_sym
+    
+    dictionary = Connie[argument.first]
+    
+    if argument[1]
+      dictionary.send argument[1], options
+    else
+      dictionary
+    end
+  when Array
+    argument[rand(argument.size)]
+  else
+    raise ArgumentError, 'Connie\'s shorthand expects a string to parse or a symbol or an array'
+  end
+end

data/lib/dictionaries/creative.color

@@ -0,0 +1,19 @@
+Red
+Blue
+Green
+Yellow
+Orange
+Purple
+Violet
+Indigo
+Teal
+Pink
+Fuscia
+Goldenrod
+Mauv
+Aquamarine
+Turquoise
+Crimson
+Maroon
+Puce
+Khaki

data/lib/dictionaries/creative.lorem_ipsum

@@ -0,0 +1,151 @@
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
+Proin risus.
+Praesent lectus.
+Vestibulum quam sapien, varius ut, blandit non, interdum in, ante.
+Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Duis faucibus accumsan odio.
+Curabitur convallis.
+Duis consequat dui nec nisi volutpat eleifend.
+Donec ut dolor.
+Morbi vel lectus in quam fringilla rhoncus.
+Mauris enim leo, rhoncus sed, vestibulum sit amet, cursus id, turpis.
+Integer aliquet, massa id lobortis convallis, tortor risus dapibus augue, vel accumsan tellus nisi eu orci.
+Mauris lacinia sapien quis libero.
+Nullam sit amet turpis elementum ligula vehicula consequat.
+Morbi a ipsum.
+Integer a nibh.
+In quis justo.
+Maecenas rhoncus aliquam lacus.
+Morbi quis tortor id nulla ultrices aliquet.
+Maecenas leo odio, condimentum id, luctus nec, molestie sed, justo.
+Pellentesque viverra pede ac diam.
+Cras pellentesque volutpat dui.
+Maecenas tristique, est et tempus semper, est quam pharetra magna, ac consequat metus sapien ut nunc.
+Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Mauris viverra diam vitae quam.
+Suspendisse potenti.
+Nullam porttitor lacus at turpis.
+Donec posuere metus vitae ipsum.
+Aliquam non mauris.
+Morbi non lectus.
+Aliquam sit amet diam in magna bibendum imperdiet.
+Nullam orci pede, venenatis non, sodales sed, tincidunt eu, felis.
+Fusce posuere felis sed lacus.
+Morbi sem mauris, laoreet ut, rhoncus aliquet, pulvinar sed, nisl.
+Nunc rhoncus dui vel sem.
+Sed sagittis.
+Nam congue, risus semper porta volutpat, quam pede lobortis ligula, sit amet eleifend pede libero quis orci.
+Nullam molestie nibh in lectus.
+Pellentesque at nulla.
+Suspendisse potenti.
+Cras in purus eu magna vulputate luctus.
+Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
+Vivamus vestibulum sagittis sapien.
+Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
+Etiam vel augue.
+Vestibulum rutrum rutrum neque.
+Aenean auctor gravida sem.
+Praesent id massa id nisl venenatis lacinia.
+Aenean sit amet justo.
+Morbi ut odio.
+Cras mi pede, malesuada in, imperdiet et, commodo vulputate, justo.
+In blandit ultrices enim.
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
+Proin interdum mauris non ligula pellentesque ultrices.
+Phasellus id sapien in sapien iaculis congue.
+Vivamus metus arcu, adipiscing molestie, hendrerit at, vulputate vitae, nisl.
+Aenean lectus.
+Pellentesque eget nunc.
+Donec quis orci eget orci vehicula condimentum.
+Curabitur in libero ut massa volutpat convallis.
+Morbi odio odio, elementum eu, interdum eu, tincidunt in, leo.
+Maecenas pulvinar lobortis est.
+Phasellus sit amet erat.
+Nulla tempus.
+Vivamus in felis eu sapien cursus vestibulum.
+Proin eu mi.
+Nulla ac enim.
+In tempor, turpis nec euismod scelerisque, quam turpis adipiscing lorem, vitae mattis nibh ligula nec sem.
+Duis aliquam convallis nunc.
+Proin at turpis a pede posuere nonummy.
+Integer non velit.
+Donec diam neque, vestibulum eget, vulputate ut, ultrices vel, augue.
+Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Donec pharetra, magna vestibulum aliquet ultrices, erat tortor sollicitudin mi, sit amet lobortis sapien sapien non mi.
+Integer ac neque.
+Duis bibendum.
+Morbi non quam nec dui luctus rutrum.
+Nulla tellus.
+In sagittis dui vel nisl.
+Duis ac nibh.
+Fusce lacus purus, aliquet at, feugiat non, pretium quis, lectus.
+Suspendisse potenti.
+In eleifend quam a odio.
+In hac habitasse platea dictumst.
+Maecenas ut massa quis augue luctus tincidunt.
+Nulla mollis molestie lorem.
+Quisque ut erat.
+Curabitur gravida nisi at nibh.
+In hac habitasse platea dictumst.
+Aliquam augue quam, sollicitudin vitae, consectetuer eget, rutrum at, lorem.
+Integer tincidunt ante vel ipsum.
+Praesent blandit lacinia erat.
+Vestibulum sed magna at nunc commodo placerat.
+Praesent blandit.
+Nam nulla.
+Integer pede justo, lacinia eget, tincidunt eget, tempus vel, pede.
+Morbi porttitor lorem id ligula.
+Suspendisse ornare consequat lectus.
+In est risus, auctor sed, tristique in, tempus sit amet, sem.
+Fusce consequat.
+Nulla nisl.
+Nunc nisl.
+Duis bibendum, felis sed interdum venenatis, turpis enim blandit mi, in porttitor pede justo eu massa.
+Donec dapibus.
+Duis at velit eu est congue elementum.
+In hac habitasse platea dictumst.
+Morbi vestibulum, velit id pretium iaculis, diam erat fermentum justo, nec condimentum neque sapien placerat ante.
+Nulla justo.
+Aliquam quis turpis eget elit sodales scelerisque.
+Mauris sit amet eros.
+Suspendisse accumsan tortor quis turpis.
+Sed ante.
+Vivamus tortor.
+Duis mattis egestas metus.
+Aenean fermentum.
+Donec ut mauris eget massa tempor convallis.
+Nulla neque libero, convallis eget, eleifend luctus, ultricies eu, nibh.
+Quisque id justo sit amet sapien dignissim vestibulum.
+Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Nulla dapibus dolor vel est.
+Donec odio justo, sollicitudin ut, suscipit a, feugiat et, eros.
+Vestibulum ac est lacinia nisi venenatis tristique.
+Fusce congue, diam id ornare imperdiet, sapien urna pretium nisl, ut volutpat sapien arcu sed augue.
+Aliquam erat volutpat.
+In congue.
+Etiam justo.
+Etiam pretium iaculis justo.
+In hac habitasse platea dictumst.
+Etiam faucibus cursus urna.
+Ut tellus.
+Nulla ut erat id mauris vulputate elementum.
+Nullam varius.
+Nulla facilisi.
+Cras non velit nec nisi vulputate nonummy.
+Maecenas tincidunt lacus at velit.
+Vivamus vel nulla eget eros elementum pellentesque.
+Quisque porta volutpat erat.
+Quisque erat eros, viverra eget, congue eget, semper rutrum, nulla.
+Nunc purus.
+Phasellus in felis.
+Donec semper sapien a libero.
+Nam dui.
+Proin leo odio, porttitor id, consequat in, consequat ut, nulla.
+Sed accumsan felis.
+Ut at dolor quis odio consequat varius.
+Integer ac leo.
+Pellentesque ultrices mattis odio.
+Donec vitae nisi.
+Nam ultrices, libero non mattis pulvinar, nulla pede ullamcorper augue, a suscipit nulla elit ac nulla.
+Sed vel enim sit amet nunc viverra dapibus.
+Nulla suscipit ligula in lacus.
+Curabitur at ipsum ac tellus semper interdum.
+Mauris ullamcorper purus sit amet nulla.
+Quisque arcu libero, rutrum ac, lobortis vel, dapibus at, diam.
+Nam tristique tortor eu pede.