linguify 0.3.0 → 0.4.0

data/Gemfile.lock

@@ -9,16 +9,16 @@ GEM
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    rake (0.9.2)
+    rake (0.9.2.2)
     rcov (0.9.11)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
+    rspec-mocks (2.7.0)
     ruby2ruby (1.3.1)
       ruby_parser (~> 2.0)
       sexp_processor (~> 3.0)

data/README.md

@@ -7,152 +7,166 @@ Since the code ends up compiled like all code should be you can execute your cod
 
 ## Installation
 
-    gem install linguify
+``` ruby
+gem install linguify
+```
 
 ## Basic usage
 
-    require 'linguify'
-
-	reduce /all directories/ => 'directories' do
-	  Dir.entries('.').select{ |f| f[0] != '.' && File.directory?(f) }
-	end
-
-	reduce /({directories:[^}]*}) recursively/ => 'directories' do |dirs|
-	  all_dirs = dirs
-	  Find.find(dirs) do |path|
-	    if FileTest.directory?(path)
-	      if File.basename(path)[0] == '.'
-	        Find.prune       # Don't look any further into this directory.
-	      else
-			all_dirs << path
-	        next
-	      end
-	    end
-	  end
-	  all_dirs
-	end
-
-	reduce /all files inside ({directories:[^}]*})/ => 'files' do |dirs|
-	  dirs.map{ |f| File.new(f, "r") }
-	end
-
-	reduce /view ({files:[^}]*})/ => '' do |files|
-	  files.each do |file|
-	    pp file
-	  end
-	end
-
-	"view all files inside all directories recursively".linguify.to_ruby
-    # => "code = lambda do
-    #       directories_0 = Dir.entries(\".\").select { |f| ((not (f[0] == \".\")) and File.directory?(f)) }
-    #       directories_1 = (all_dirs = directories_0
-	#       Find.find(directories_0) do |path|
-	#         if FileTest.directory?(path) then
-	#           if (File.basename(path)[0] == \".\") then
-	#             Find.prune
-	#           else
-	#             (all_dirs << path)
-	#             next
-	#           end
-	#         end
-	#       end
-	#       all_dirs)
-	#       files_2 = directories_1.map { |f| File.new(f, \"r\") }
-	#       files_2.each { |file| pp(file) }
-	#     end
-	#   " 
+``` ruby
+require 'linguify'
+
+reduce /all directories/ => 'directories' do
+  Dir.entries('.').select{ |f| f[0] != '.' && File.directory?(f) }
+end
+
+reduce /({directories:[^}]*}) recursively/ => 'directories' do |dirs|
+  all_dirs = dirs
+  Find.find(dirs) do |path|
+    if FileTest.directory?(path)
+      if File.basename(path)[0] == '.'
+        Find.prune       # Don't look any further into this directory.
+      else
+		all_dirs << path
+        next
+      end
+    end
+  end
+  all_dirs
+end
+
+reduce /all files inside ({directories:[^}]*})/ => 'files' do |dirs|
+  dirs.map{ |f| File.new(f, "r") }
+end
+
+reduce /view ({files:[^}]*})/ do |files|
+  files.each do |file|
+    pp file
+  end
+end
+
+"view all files inside all directories recursively".linguify.to_ruby
+# => "code = lambda do
+#       directories_0 = Dir.entries(\".\").select { |f| ((not (f[0] == \".\")) and File.directory?(f)) }
+#       directories_1 = (all_dirs = directories_0
+#       Find.find(directories_0) do |path|
+#         if FileTest.directory?(path) then
+#           if (File.basename(path)[0] == \".\") then
+#             Find.prune
+#           else
+#             (all_dirs << path)
+#             next
+#           end
+#         end
+#       end
+#       all_dirs)
+#       files_2 = directories_1.map { |f| File.new(f, \"r\") }
+#       files_2.each { |file| pp(file) }
+#     end
+#   " 
+```
 	
 And if you simply want to execute your magnificent piece of art:
 
-	"view all files inside all directories recursively".linguify.run
+``` ruby
+"view all files inside all directories recursively".linguify.run
+```
 
 Or even:
 
-    # compile once, run plenty
-    code = "view all files inside all directories recursively".linguify
-    loop do
-      code.run
-    end
+``` ruby
+# compile once, run plenty
+code = "view all files inside all directories recursively".linguify
+loop do
+  code.run
+end
+```
 
 ## More advanced usage
 
 Linguify supports mixing javascript and ruby.
 A typical case would be to express NOSQL queries in plain English for everyones convenience.
 
-    require 'linguify'
+``` ruby
+require 'linguify'
 
-    reduce /a possible javascript NOSQL query/ => {:to => 'query', :lang => :js} do
-      @db.forEach(lambda{ |record|
-          emit(record);
-        }
-      )
-    end
+reduce /a possible javascript NOSQL query/ => {:to => 'query', :lang => :js} do
+  @db.forEach(lambda{ |record|
+      emit(record);
+    }
+  )
+end
 
-    reduce /execute ({query:[^}]*})/ => '' do |query|
-      db.map query
-    end
+reduce /execute ({query:[^}]*})/ do |query|
+  db.map query
+end
 
-    "execute a possible javascript NOSQL query".linguify.to_ruby
-    # => "code = lambda do
-    #       query = \"function(){\\n  this.db.forEach(function(record){\\n    emit(record)\\n  });\\n}\"
-    #       db.map(query)
-    #     end
-    #    "
+"execute a possible javascript NOSQL query".linguify.to_ruby
+# => "code = lambda do
+#       query = \"function(){\\n  this.db.forEach(function(record){\\n    emit(record)\\n  });\\n}\"
+#       db.map(query)
+#     end
+#    "
+```
 
 The nature of Linguify's expression reduction face pragmatic programmers with a urge to inline the code the arguments represents.
 Luckily Linguify has evolved to embrace such minds. Linguify is not for the general masses. It is for the mighty few pragmatics.
 
-    require 'linguify'
-
-    reduce /inlined code/ => {:to => 'code', :lang => :ruby, :inline => true} do
-      something.each do |foobar| # life is not worth living without psedo foobars
-        pp foobar
-      end
-    end
-
-    reduce /execute ({code:[^}]*})/ => '' do |code|
-      pp "hey mum"
-      code
-      pp "you will never know what I just did"
-	end
-
-	"execute inlined code".linguify.to_ruby
-	# => "code = lambda do
-	#       (pp(\"hey mum\")
-	#       (something.each { |foobar| pp(foobar) })
-	#       pp(\"you will never know what I just did\"))
-	#     end
-	#    "
+``` ruby
+require 'linguify'
+
+reduce /inlined code/ => {:to => 'code', :lang => :ruby, :inline => true} do
+  something.each do |foobar| # life is not worth living without psedo foobars
+    pp foobar
+  end
+end
+
+reduce /execute ({code:[^}]*})/ do |code|
+  pp "hey mum"
+  code
+  pp "you will never know what I just did"
+end
+
+"execute inlined code".linguify.to_ruby
+# => "code = lambda do
+#       (pp(\"hey mum\")
+#       (something.each { |foobar| pp(foobar) })
+#       pp(\"you will never know what I just did\"))
+#     end
+#    "
+```
 
 And you can even inline sub-expressions:
 
-    require 'linguify'
-
-	reduce /sub expression/ => {:to => 'sub_expression', :lang => :ruby, :inline => true} do
-	  pp "this is the sub expression code"
-	end
-
-	reduce /({sub_expression:[^}]*}) of inlined code/ => {:to => 'code', :lang => :ruby, :inline => true} do |sub|
-	  something.each do |foobar| # life is not worth living without psedo foobars
-	    pp foobar
-	  end
-	end
-
-	reduce /execute ({code:[^}]*})/ => '' do |code|
-	  pp "hey mum"
-	  code
-	  code[:sub]
-	  pp "you will never know what I just did"
-	end
-
-	"execute sub expression of inlined code".linguify.to_ruby
-	# => "code = lambda do
-	#       (pp(\"hey mum\")
-	#       (something.each { |foobar| pp(foobar) })
-	#       pp(\"this is the sub expression code\")
-	#       pp(\"you will never know what I just did\"))
-	#     end
-	#    "
+``` ruby
+require 'linguify'
+
+reduce /sub expression/ => {:to => 'sub_expression', :lang => :ruby, :inline => true} do
+  pp "this is the sub expression code"
+end
+
+reduce /({sub_expression:[^}]*}) of inlined code/ => {:to => 'code', :lang => :ruby, :inline => true} do |sub|
+  something.each do |foobar| # life is not worth living without psedo foobars
+    pp foobar
+  end
+end
+
+reduce /execute ({code:[^}]*})/ do |code|
+  pp "hey mum"
+  code
+  code[:sub]
+  pp "you will never know what I just did"
+end
+
+"execute sub expression of inlined code".linguify.to_ruby
+# => "code = lambda do
+#       (pp(\"hey mum\")
+#       (something.each { |foobar| pp(foobar) })
+#       pp(\"this is the sub expression code\")
+#       pp(\"you will never know what I just did\"))
+#     end
+#    "
+```
 
 ## License
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/linguify/linguified.rb

@@ -11,8 +11,8 @@ module Linguify
 
     # Lingquify a sentence
     #
-    # * +str+     - A plain English string, or a plain English string with reductions in it.
-    # * +replace+ - In which "scope" to bind the code during compilation
+    # @param [ String ] string A plain English string, or a plain English string with reductions in it.
+    # @param [ Binding ] binding See +Kernel#eval+
     #
     def initialize str,bind
 
@@ -66,7 +66,7 @@ module Linguify
     
     # Find a reduction rule for the string
     #
-    # * +str+     - A plain English string, or a plain English string with reductions in it.
+    # @param [ String ] string A plain English string, or a plain English string with reductions in it.
     #
     def find_rule str
       found = Linguify.rules.select do |rule|

data/lib/linguify/proc.rb

@@ -1,6 +1,11 @@
 # encoding: utf-8
 
 class Proc
+
+  # Translate the Proc to a +Reduction+.
+  #
+  # @returns [ Reduction ] A +Reduction+ containing the code of the Proc.
+  #
   def to_reduction args={}
     Linguify::Reduction.new(
       :returns  => args[:returns] || '',
@@ -19,7 +24,7 @@ class Proc
 
     sexy = reduction.compile
     code = Marshal.load(Marshal.dump(sexy.first)) # sexy is not cleanly duplicated
-    code.replace_variable_references!(Linguify::Replacement.new(:sexp => collection.name),:collection)
+    code.replace_variable_references! :replacement => Linguify::Replacement.new(:sexp => collection.name), :needle => :collection
     code
   end
 end

data/lib/linguify/reduction.rb

@@ -36,6 +36,10 @@ module Linguify
       @@reductions << self
     end
 
+    # Extract the arguments from the code block of this Reduction.
+    #
+    # @returns [ Hash ] Key valye pairs of symbolized variable names and the reduction reference.
+    #
     def determine_arguments
       s = Marshal.load(Marshal.dump(self)) # sexp handling is not clean cut
       raise "what is this?" unless s.sexp.sexp_type == :iter && s.sexp[1].sexp_type == :call && s.sexp[1][1] == nil && s.sexp[1][2] == :proc && s.sexp[1][3].sexp_type == :arglist
@@ -57,11 +61,14 @@ module Linguify
           raise "unsupported argument type #{args}"
         end
       end
-      # args[] now has the symbolized argument names of the code block
       @named_args = Hash[*args.zip(@args).flatten] if args
       @named_args ||= {}
     end
 
+    # Parse the string and return its reduction rule.
+    #
+    # @returns [ Reduction ] The reduction rule of the string.
+    #
     def self.parse str
       if /^{(?<return>[^:]*):(?<rid>[0-9]+)}$/ =~ str
         @@reductions[rid.to_i]
@@ -78,10 +85,13 @@ module Linguify
 
     # Compile self
     #
-    # * +return_variable+ - The return variable. Can either be a symbol representing the variable name or nil to skip variable assigning.
-    # * +replace+         - A list of variables in need of a new unique name or replacement with inlined code
+    # @param [ Symbol,nil ] return_variable The variable in the code wanting the result.
+    # @param [ Array<Symbol,Sexp>] replacement A list of variables in need of a new unique name or replacement with inlined code
+    # @returns [ Array<Sexp> ] the compiled code
     #
-    def compile_with_return_to_var(return_variable=nil, replace = {})
+    def compile_with_return_to_var params={}
+      replace = params[:replace] || {}
+
       s = Marshal.load(Marshal.dump(self)) # sexp handling is not clean cut
       args = @named_args.keys
       # args[] now has the symbolized argument names of the code block
@@ -94,7 +104,7 @@ module Linguify
           red = Reduction::parse(arg)
           if red.lang != lang && red.lang == :js && lang == :ruby
             # paste javascript code into a ruby variable
-            code = red.compile_with_return_to_var(nil,replace)
+            code = red.compile_with_return_to_var :replace => replace
             clone = Marshal.load(Marshal.dump(code)) # code is not cleanly duplicated
             code = Sexp.new(:iter,Sexp.new(:call, nil, :lambda, Sexp.new(:arglist)), nil,
               Sexp.new(:block,
@@ -107,10 +117,10 @@ module Linguify
           else
             raise "trying to reference #{red.lang} code in #{lang} code" if red.lang != lang
             if red.inline
-              code = red.compile_with_return_to_var(nil,replace)
+              code = red.compile_with_return_to_var :replace => replace
               replace[args[i]] = Replacement.new(:sexp => Sexp.new(:block,*code), :inline => true)
             else
-              code = red.compile_with_return_to_var("#{ret}_#{n}".to_sym,replace)
+              code = red.compile_with_return_to_var :return_variable => "#{ret}_#{n}".to_sym, :replace => replace
               args_code += code
               replace[args[i]] = Replacement.new(:sexp => "#{ret}_#{n}".to_sym)
             end
@@ -123,27 +133,31 @@ module Linguify
         end
       end
 
-      if return_variable
+      if params[:return_variable]
         if s.sexp[3][0] == :block
-          code = Sexp.new(:lasgn, return_variable,
+          code = Sexp.new(:lasgn, params[:return_variable],
             Sexp.new(:block,
               *(s.sexp[3][1..-1].map{ |s| s.dup })
             )
           )
         else
-          code = Sexp.new(:lasgn, return_variable, s.sexp[3].dup)
+          code = Sexp.new(:lasgn, params[:return_variable], s.sexp[3].dup)
         end
       else
         code = s.sexp[3].dup
       end
 
       replace.each do |k,v|
-        code.replace_variable_references!(v,k,@named_args)
+        code.replace_variable_references! :replacement => v, :needle => k, :named_args => @named_args
       end
 
       return *args_code + [code]
     end
 
+    # Get the reduction reference for this Reduction.
+    #
+    # @returns [ String ] A unique string reference refering to this Reduction.
+    #
     def to_rexp
       raise "hell" if returns.kind_of?(Array)
       "{#{returns}:#{reduction_id}}"

data/lib/linguify/sexp.rb

@@ -4,12 +4,16 @@ class Sexp < Array
 
   # Recurcively replace all references in a code section
   #
-  # * +code+        - The code haystack to search and replace in
-  # * +replacement+ - The replacement code. Either a Sexp (containing code to inline) or a symbol
-  # * +needle+      - The search needle
+  # @param [ Sexp, Symbol ] replacement The replacement code. Either a Sexp (containing code to inline) or a symbol
+  # @param [ Sexp ] needle The search needle
+  # @param [ Hash ] named_args The arguments of the code block
   #
-  def replace_variable_references!(replacement,needle,named_args="")
+  def replace_variable_references! params
     
+    replacement = params[:replacement]
+    needle      = params[:needle]
+    named_args  = params[:named_args] || ''
+
     case sexp_type
     when :lasgn
       self[1]=replacement.sexp if self[1] == needle
@@ -46,12 +50,12 @@ class Sexp < Array
           sexy = Marshal.load(Marshal.dump(Linguify::Reduction.parse(Linguify::Reduction.parse(named_args[needle]).named_args[arg]).sexp)) # sexp handling is not clean cut
           self[i+1] = sexy[3]
         else
-          h.replace_variable_references!(replacement,needle,named_args) if h && h.kind_of?(Sexp)
+          h.replace_variable_references!(:replacement => replacement, :needle => needle, :named_args => named_args) if h && h.kind_of?(Sexp)
         end
       end
     else
       self[1..-1].each do |h|
-        h.replace_variable_references!(replacement,needle,named_args) if h && h.kind_of?(Sexp)
+        h.replace_variable_references!(:replacement => replacement, :needle => needle, :named_args => named_args) if h && h.kind_of?(Sexp)
       end
     end
   end

data/lib/linguify/string.rb

@@ -1,9 +1,23 @@
 # encoding: utf-8
 
 class String
+
+  # Linguify the string.
+  #
+  # @param   [ Binding ]    binding See the +Kernel#eval+.
+  # @returns [ Linguified ] code    The compiled code
+  #
+  # @example Linguify a string and translate it back to Ruby
+  #   "this is the famous hello world".linguify.to_ruby
+  #   # => "code = lambda do
+  #   #       (pp(\"hello world\")
+  #   #     end
+  #   #    "
+  #
   def linguify bind=binding
     return Linguify::Linguified::cache[self] if Linguify::Linguified::cache[self]
     Linguify::Linguified::cache[self] = Linguify::Linguified.new(self,bind)
   end
+
 end
 

data/lib/linguify/translators/javascript.rb

@@ -469,6 +469,10 @@ class Ruby2Js < SexpProcessor
     exp.empty? ? "" : process(exp.shift)
   end
 
+  def process_str(exp)
+    "\"#{exp.shift.to_s}\""
+  end
+  
   def process_true(exp)
     "true"
   end

data/lib/linguify.rb

@@ -6,20 +6,57 @@ require 'linguify/sexp'
 require 'linguify/string'
 require 'linguify/proc'
 
+# Defines a reduction rule.
+#
+# @param [ Hash ] pattern The step matching pattern
+# @param [ Proc ] code    The code
+#
+#   The step matching pattern only one key-value pair, where the
+#     key is the step matching pattern and the
+#     value is on of:
+#       nil      - indicating the last reduction,
+#       +String+ - the name of the reduction,
+#       +Hash+   - the name of the reduction and adittional parameters
+#
+#   Supported parameters:
+#     :to     - the name of the reduction
+#     :lang   - what language the code block translates to. (:ruby or :js)
+#     :inline - if true, calls to this reduction will be inlined
+#
+# @example Define a reduction rule that reduce a text to a javascript reduction named query.
+#   reduce /a possible javascript NOSQL query/ => {:to => 'query', :lang => :js} do
+#     @db.forEach(lambda{ |record|
+#         emit(record);
+#       }
+#     )
+#   end
+#
 def reduce(regexp,&code)
-  rule = regexp.values[0].kind_of?(Hash) ? {
-    :match  => regexp.keys[0],
-    :result => regexp.values[0][:to]     || '',
-    :lang   => regexp.values[0][:lang]   || :ruby,
-    :inline => regexp.values[0][:inline] || false,
-    :proc => code
-  } : {
-    :match  => regexp.keys[0],
-    :result => regexp.values[0],
-    :lang   => :ruby,
-    :inline => false,
-    :proc => code
-  }
+  rule = if regexp.kind_of? Regexp
+    {
+      :match  => regexp,
+      :result => '',
+      :lang   => :ruby,
+      :inline => false,
+      :proc => code
+    }
+  elsif regexp.values[0].kind_of?(Hash)
+    {
+      :match  => regexp.keys[0],
+      :result => regexp.values[0][:to]     || '',
+      :lang   => regexp.values[0][:lang]   || :ruby,
+      :inline => regexp.values[0][:inline] || false,
+      :proc => code
+    }
+  else
+   {
+      :match  => regexp.keys[0],
+      :result => regexp.values[0],
+      :lang   => :ruby,
+      :inline => false,
+      :proc => code
+    }
+  end
   Linguify::rules << rule
 end
 

data/linguify.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{linguify}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Patrick Hanevold}]
+  s.date = %q{2011-10-27}
+  s.description = %q{Linguify is a linguistic compiler allowing you to compile and execute plain english.}
+  s.email = %q{patrick.hanevold@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/linguify.rb",
+    "lib/linguify/linguified.rb",
+    "lib/linguify/proc.rb",
+    "lib/linguify/reduction.rb",
+    "lib/linguify/sexp.rb",
+    "lib/linguify/string.rb",
+    "lib/linguify/translators/javascript.rb",
+    "linguify.gemspec",
+    "spec/linguify/linguify_spec.rb",
+    "tasks/spec.rake"
+  ]
+  s.homepage = %q{http://github.com/patrickhno/linguify}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.8}
+  s.summary = %q{Linguify, the linguistic compiler.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sourcify>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<sourcify>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<sourcify>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/spec/linguify/linguify_spec.rb

@@ -29,7 +29,7 @@ describe Linguify::Linguified, "#linguify" do
       dirs.map{ |f| File.new(f, "r") }
     end
 
-    reduce /view ({files:[^}]*})/ => '' do |files|
+    reduce /view ({files:[^}]*})/ do |files|
       files.each do |file|
         pp file
       end
@@ -46,7 +46,7 @@ describe Linguify::Linguified, "#linguify" do
       )
     end
 
-    reduce /execute ({query:[^}]*})/ => '' do |query|
+    reduce /execute ({query:[^}]*})/ do |query|
       db.map query
     end
 
@@ -64,7 +64,7 @@ describe Linguify::Linguified, "#linguify" do
       end
     end
 
-    reduce /execute ({code:[^}]*})/ => '' do |code|
+    reduce /execute ({code:[^}]*})/ do |code|
       pp "hey mum"
       code
       code[:sub]

metadata

@@ -2,7 +2,7 @@
 name: linguify
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Patrick Hanevold
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-22 00:00:00 Z
+date: 2011-10-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sourcify
@@ -87,7 +87,6 @@ extensions: []
 extra_rdoc_files: 
 - README.md
 files: 
-- .document
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -100,6 +99,7 @@ files:
 - lib/linguify/sexp.rb
 - lib/linguify/string.rb
 - lib/linguify/translators/javascript.rb
+- linguify.gemspec
 - spec/linguify/linguify_spec.rb
 - tasks/spec.rake
 homepage: http://github.com/patrickhno/linguify
@@ -115,7 +115,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3911346781784924082
+      hash: 1805068760905318468
       segments: 
       - 0
       version: "0"

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt