nlg 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+doc/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in nlg.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :test
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' <<'test'
+  test.pattern =  'test/*_test.rb'
+  test.verbose = true
+end
+#  test.pattern =  'test/*_test.rb'

data/lib/nlg.rb

@@ -0,0 +1,12 @@
+require "active_support"
+require "verbs"
+require "nlg/sentence"
+require "nlg/nlg_exception"
+require "nlg/version"
+require "nlg/paragraph"
+require "nlg/sentence"
+require "nlg/sentence_object"
+
+module Nlg
+  # Your code goes here...
+end

data/lib/nlg/nlg_exception.rb

@@ -0,0 +1,2 @@
+class NlgException < Exception
+end

data/lib/nlg/paragraph.rb

@@ -0,0 +1,125 @@
+module Nlg
+  class Paragraph
+   
+    attr_accessor :defaults, :dataset, :sentences
+    # The parameters, dataset and defaults are both hashes.
+    # For example:
+    #
+    # defaults = { "tense" => "present",
+    #               "verb" => "have", 
+    #               "pronoun" => "it",
+    #               "voice" => "active",
+    #               "aspect" => "habitual",
+    #               "preposition" => "of" }
+    #
+    # dataset = {"subject"=>"Pune", 
+    #            "objects"=>
+    #              { "population"=>
+    #                  {"value"=>"57841284790", 
+    #                   "specifications"=>{}}, 
+    #                "rainfall"=>
+    #                  {"value"=>"198", 
+    #                   "specifications"=>{"complement"=>"mm"}}, 
+    #                "high temperature"=>
+    #                  {"value"=>"45", 
+    #                   "specifications"=>{"complement"=>"°C"}, 
+    #                   "conjugated_with"=>["low temperature"]}, 
+    #                "low temperature"=>
+    #                  {"value"=>"20", 
+    #                   "specifications"=>{"complement"=>"°C"}, 
+    #                   "conjugated_with"=>["high temperature", "low temperature", "rainfall"]}, 
+    #                "forts"=>
+    #                  {"value"=>["sinhgad", "lohgad"], 
+    #                   "specifications"=>{"preposition"=>"named"}, 
+    #                   "conjugated_with"=>["high temperature", "low temperature", "rainfall"]}
+    #              }
+    #           }
+    #
+    # method to set defaults, build_conjugations and initialize other attributes
+    def initialize(dataset, defaults)
+      @subject = dataset['subject']
+      @objects = {}
+      @conjugations = {}
+      @defaults = defaults
+      @sentences = []
+    
+      # Iterating through all the objects and building conjugations.  
+      dataset['objects'].each do |object_type, object_details|
+        # A check to allow objects to be created with "conjugated" => false only if not already
+        # present. build_conjugations method called which recursively builds the conjugations.
+        unless @objects.has_key?(object_type)
+          sentence_object = SentenceObject.new(object_type, object_details, "conjugated" => false)
+          @objects[object_type] = sentence_object
+          build_conjugations(object_type, dataset['objects']) 
+        end 
+      end
+ 
+    end
+  
+    def build
+      puts @conjugations.inspect, @objects.inspect
+      # Paragraph generation by generating individual sentences.   
+      @objects.each do |object_type, sentence_object|
+        sentence = Sentence.new(:subject => @subject, :specifications => @defaults.merge(sentence_object.specifications))
+        @sentences << sentence.build(object_type, sentence_object)
+      end
+    end
+    
+    # Method called internally in initialize to build conjugations among sentences of a paragraph.
+    # The example dataset will give the conjugations,
+    # 
+    #   @conjugations ={"population"=>[], "forts"=>["low temperature", "rainfall", "high temperature"]}
+    def build_conjugations(object_type, objects, parent_object = nil)
+      object_details = objects[object_type]
+      
+      # Condition for setting the parent_object to be passed recursively
+      parent_object = object_type unless parent_object
+     
+      # Creating the @conjugations[parent_object] array recursively to finally
+      # build the conjugations.  
+      conjugated_with = object_details['conjugated_with']
+      
+      unless conjugated_with.nil? or conjugated_with.empty?
+        conjugated_with.each do |conjugated_object|
+          if objects.has_key?(conjugated_object)
+           
+            # Creating object with "conjugated" => true if its present in "conjugated_with" array. 
+            unless @objects.has_key?(conjugated_object)
+              sentence_object = SentenceObject.new(conjugated_object, objects[conjugated_object], "conjugated" => true)
+              @objects[conjugated_object] = sentence_object
+            end
+            
+            # Creating array if does not already exist.
+            @conjugations[parent_object] ||= []
+            
+            # Checking if currently iterating object included in the array already/is the parent_object itself.
+            unless @conjugations[parent_object].include?(conjugated_object) or conjugated_object == parent_object
+
+              # If an already parsed object with "conjugated" = false comes as a conjugation
+              # to the object being parsed.
+              if @objects[conjugated_object].conjugated == false      
+                @objects[conjugated_object].conjugated = true
+                @conjugations[parent_object] = @conjugations[parent_object].concat(@conjugations[conjugated_object]).uniq
+                @conjugations.delete(conjugated_object)
+              end
+              
+              # Appending to the conjugations array for the parent_object.
+              @conjugations[parent_object] << conjugated_object
+  
+              # recursive call for building conjugations for a parent_object
+              build_conjugations(conjugated_object, objects, parent_object)
+            end
+          else
+            raise NlgException.new "No object named #{conjugation_object}"
+          end
+        end
+      else 
+   
+        # adding independent sentences which have no conjugations 
+        @conjugations[object_type] = [] if @objects[object_type].conjugated == false
+      end
+    
+    end
+  end
+
+end

data/lib/nlg/sentence.rb

@@ -0,0 +1,52 @@
+module Nlg  
+  class Sentence
+  
+    attr_accessor :verb, :tense, :pronoun, :voice, :subject, :value, :object
+    attr_accessor :complement, :coordination_phrase, :preposition, :aspect
+  
+  	def initialize(args = {})
+  		specifications = args[:specifications]
+      @verb = specifications["verb"] || (raise NlgException.new "Verb is nil") 
+      @tense = specifications["tense"] || (raise NlgException.new "tense is nil")
+      @pronoun = specifications["pronoun"] || (raise NlgException.new "pronoun is nil")
+      @complement = specifications["complement"]  
+      @coordination_phrase = specifications["coordination_phrase"]  
+      @voice = specifications["voice"]  
+      @aspect = specifications["aspect"] || (raise NlgException.new "aspect is nil")
+      @preposition = specifications["preposition"]  
+  		@subject = args[:subject] || true
+  	end
+    
+    #method to build a sentence. Returns the formed sentece to build_paragraph
+    def build(object_type, object_details)
+      self.value = object_details.value
+      self.value = value.join(',') if value.is_a?(Array)
+      self.object = object_type
+      formed_sentence = self.form
+      return formed_sentence
+    end
+  
+    #method to form the sentence using the given specifications
+    def form
+      set_tense
+      predicate = set_predicate
+      formed_sentence = "#{verb} #{predicate}".verb.conjugate :subject => subject, :tense => tense.to_sym, :aspect => aspect.to_sym
+      return  "#{formed_sentence} #{complement}" 
+    end 
+  
+    def set_tense
+      if tense == "past" and aspect == "habitual" 
+        self.aspect = "perfective"
+      end
+    end
+  
+    def set_predicate
+      predicate = "#{preposition} #{value}"
+      if verb == "have"
+        predicate = "#{object} #{preposition} #{value}" 
+      end
+      return predicate
+    end
+  
+  end
+end

data/lib/nlg/sentence_object.rb

@@ -0,0 +1,15 @@
+module Nlg
+  class SentenceObject
+    attr_accessor :specifications, :value, :object_type, :conjugated
+
+    def initialize(object_type, object_details, options={})
+      puts object_details
+      @specifications = object_details['specifications'] if object_details['specifications'] 
+      @value = object_details['value']
+      @object_type = object_type
+      @conjugated = options["conjugated"]
+    end
+
+  end
+end
+

data/lib/nlg/version.rb

@@ -0,0 +1,3 @@
+module Nlg
+  VERSION = "0.0.1"
+end

data/nlg.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nlg/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nlg"
+  s.version     = Nlg::VERSION
+  s.authors     = ["Sricharan Sunder", "Jiren Patel", "Gautam Rege"]
+  s.email       = ["sricharan@joshsoftware.com", "jiren@joshsoftware.com", "gautam@joshsoftware.com"]
+  s.homepage    = "http://github.com/joshsoftware/nlg"
+  s.summary     = %q{Natural Language Generation in Ruby}
+  s.description = %q{Build articles and paragraphs from structured data. Instead of a standard tempate, we can use this to build articles that are grammatically correct and creative.}
+
+  s.rubyforge_project = "nlg"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_dependency "verbs" 
+  s.add_dependency "active_support" 
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/test/json.txt

@@ -0,0 +1,84 @@
+{ "defaults":
+  { "tense": "present",
+    "verb": "be",
+    "pronoun": "he", 
+    "voice": "active",
+    "aspect": "habitual"
+  },
+
+  "subjects":
+    {  
+      "subject": "Sricharan",
+      "objects": [
+      { "object" : "location",
+        "value": "aundh",
+        "specifications":
+        {
+        "verb": "live",
+        "preposition": "in",
+        "tense": "past", 
+        "coordinated": true,
+        "coordination_phrase": "and"}
+      },
+      
+       
+      { "object": "age", 
+        "value": "19",
+        "specifications": 
+        {"complement": "years old"
+        }
+      },
+     
+      
+      { "object": "workplace",
+        "value": "Josh Software",
+        "specifications":
+        {
+        "verb": "work",
+        "preposition": "in",
+        "coordinated": true,
+        "coordination_phrase": "and"}
+      },
+        
+      
+      { "object": "interest",
+        "value": ["music", "football", "movies"],
+        "specifications":
+        {
+        "verb": "like",
+        "coordinated": true,
+        "coordination_phrase": "and" }
+      },
+      
+      
+      { "object": "achievement",
+        "value": "xyz", 
+        "specifications":
+        {
+        "verb": "achieve",
+        "aspect": "perfect",
+        "coordinated": true,
+        "coordination_phrase": "and"}
+      },
+     
+      
+      { "object": "height",
+        "value": "185",
+        "specifications":
+        {
+        "complement": "cm tall"}
+      },
+   
+      
+      { "object": "weight",
+        "value": "70",
+        "specifications":
+        {
+        "verb": "weigh",
+        "complement": "kg"}
+      }
+     ]
+    }
+ 
+}
+

data/test/json_place.txt

@@ -0,0 +1,65 @@
+{ "defaults":
+  { "tense": "present",
+    "verb": "have",
+    "pronoun": "it", 
+    "voice": "active",
+    "aspect": "habitual",
+    "preposition": "of"
+  },
+
+  "subjects":
+    { 
+      "subject": "Pune",
+      "objects": {
+        "population":{
+          "value": "57841284790",
+          "specifications":
+          {
+   
+          }
+        },
+      
+       
+        "rainfall": {
+          "value": "198",
+          "specifications": 
+          {
+          "complement": "mm"}
+          
+        },
+     
+       
+        "high temperature": {
+          "value": "45",
+          "specifications": {
+         		 "complement": "°C"
+		  		},
+          "conjugated_with": ["low temperature"]
+        },
+         
+      
+        "low temperature": {
+          "value": "20",
+          "specifications":
+          { 
+          "complement": "°C" },
+          "conjugated_with": ["high temperature", "low temperature", "rainfall"]
+        },
+      
+      
+      
+        "forts": {
+          "value": ["sinhgad", "lohgad"],
+          "specifications":
+          {
+          "preposition": "named"
+          },
+          "conjugated_with": ["high temperature", "low temperature", "rainfall"]
+          
+        }
+     }
+    }
+  
+ 
+}
+

data/test/json_thing.txt

@@ -0,0 +1,57 @@
+{ "defaults":
+  { "tense": "present",
+    "verb": "be",
+    "pronoun": "it", 
+    "voice": "active",
+    "aspect": "habitual"
+  },
+
+  "subjects":
+    { 
+      "subject": "ABCD",
+      "objects": [
+      { "object" : "type",
+        "value": "bottle",
+        "specifications":
+        {"preposition": "a"
+        }
+      },
+      
+       
+      { "object": "height",
+        "value": "123",
+        "specifications": 
+        {
+        "complement": "mm high."}
+      },
+     
+      
+      { "object": "dimension",
+        "value": "12*2*3",
+        "specifications":
+        {"verb": "have"
+        }
+      },
+        
+      
+      { "object": "weight",
+        "value": "20",
+        "specifications":
+        {"verb": "weigh",
+        "complement": "gm" }
+      },
+      
+      
+      
+      { "object": "cost",
+        "value": "123",
+        "specifications":
+        {"verb": "cost",
+        "complement": "rupees."
+        }
+      }
+     ]
+    }
+ 
+}
+

data/test/sentence_test.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+
+class SentenceTest < ActiveSupport::TestCase
+
+  def setup
+    dataset_json = File.read("test/sentence_test_json.txt")
+    dataset = JSON.parse(dataset_json)
+    @defaults = dataset['defaults']
+    @subject = dataset['subjects']['subject']
+    @objects = dataset['subjects']['objects']
+    @objects.each do |object_type, object_details|
+      @sentence_hash= {object_type => object_details}
+    end    
+  end  
+
+  def teardown
+
+  end
+
+  test "should init sentence" do 
+    sentence = Nlg::Sentence.new(:subject => @subject, :specifications => @defaults.merge(@sentence_hash[@sentence_hash.keys.first]["specifications"])) 
+    assert_equal @subject, sentence.subject
+  end
+ 
+  test "" do 
+    @subject = nil
+    assert_raise NlgException
+      Sentence.new()
+    
+  end
+end

data/test/sentence_test_json.txt

@@ -0,0 +1,28 @@
+{ "defaults":
+  { "tense": "present",
+    "verb": "have",
+    "pronoun": "it", 
+    "voice": "active",
+    "aspect": "habitual",
+    "preposition": "of"
+  },
+
+  "subjects":
+    { 
+      "subject": "Pune",
+      "objects": {
+        "population":{
+          "value": "57841284790",
+          "specifications":
+          {
+   
+          }
+        }
+      
+       
+     }
+    }
+  
+ 
+}
+

data/test/test2.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "nlg"
+
+dataset_json = File.read("json_place.txt")
+dataset = JSON.parse(dataset_json)
+paragraph = Nlg::Paragraph.new(dataset["subjects"], dataset["defaults"])
+paragraph.build
+paragraph.sentences.each do |sentence|
+  puts sentence
+end
+
+

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require "test/unit"
+require 'active_support/test_case'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "nlg"
+
+

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: nlg
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sricharan Sunder
+- Jiren Patel
+- Gautam Rege
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: verbs
+  requirement: &10469010 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *10469010
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &10468800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *10468800
+description: Build articles and paragraphs from structured data. Instead of a standard
+  tempate, we can use this to build articles that are grammatically correct and creative.
+email:
+- sricharan@joshsoftware.com
+- jiren@joshsoftware.com
+- gautam@joshsoftware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- lib/nlg.rb
+- lib/nlg/nlg_exception.rb
+- lib/nlg/paragraph.rb
+- lib/nlg/sentence.rb
+- lib/nlg/sentence_object.rb
+- lib/nlg/version.rb
+- nlg.gemspec
+- test/json.txt
+- test/json_place.txt
+- test/json_thing.txt
+- test/sentence_test.rb
+- test/sentence_test_json.txt
+- test/test2.rb
+- test/test_helper.rb
+homepage: http://github.com/joshsoftware/nlg
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: nlg
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Natural Language Generation in Ruby
+test_files:
+- test/json.txt
+- test/json_place.txt
+- test/json_thing.txt
+- test/sentence_test.rb
+- test/sentence_test_json.txt
+- test/test2.rb
+- test/test_helper.rb