annlat 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZWM2MzMyZTlkMWVkZTNlYWZlNDJhMDBhNjZjMTM2Nzg0OGYxN2I4OQ==
+  data.tar.gz: !binary |-
+    OGZiMjM5MDg3ZTMzNWExZDcyNjZjMjMyOWZkMTM4ODIyNzFmMjM0MA==
+SHA512:
+  metadata.gz: !binary |-
+    MWVlYzM0MzAyYzQ1YjkzMjQ3YTZiMThjNzFhNGY1MmUzZjY4ZmNhZGFjNmM4
+    N2RhOGJiNTQ5NDg5MDU4Y2UyNjk3YzI5NWY3ZDliODk3Zjk1YWVmODVkNjEx
+    NTc2YTA5YTFhODhjMzgwOWVjZTcwNGZmMzU1MWNmMGYyNmZjM2Y=
+  data.tar.gz: !binary |-
+    MDdjYzljZGNjMWFhNmI5ODdjYmZjNzFmOWZhNmNiZGJkYTBhNzRlMjhlMzVl
+    MmEzOGVkMDNkMjM0NmVkMTc0NGY0MWM5NDM1MzVmNzg4ZGIyYzFlMjNmNzZk
+    MzJiNDBiNTY3YTcxMTkxMjU1NzlhNjEzNjJhMDBkN2MwZTM4ZDY=

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'fileutils'
+gem 'json'
+
+# Specify your gem's dependencies in annlat.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alexander Shevtsov
+
+MIT License
+
+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.md

@@ -0,0 +1,29 @@
+# Annlat
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'annlat'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install annlat
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/annlat/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/annlat.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'annlat/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "annlat"
+  spec.version       = Annlat::VERSION
+  spec.authors       = ["Alexander Shevtsov"]
+  spec.email         = ["randomlogin76@gmail.com"]
+  spec.summary       = "Learnleague gem for containg used libraries"
+  spec.description   = ''
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+
+end

data/lib/annlat.rb

@@ -0,0 +1,9 @@
+require "annlat/version"
+require 'annlat/LaRuby'
+require 'annlat/Concept'
+require 'annlat/Sundries'
+require 'annlat/AnnLat'
+
+module Annlat
+  # Your code goes here...
+end

data/lib/annlat/AnnLat.rb

@@ -0,0 +1,235 @@
+# The class AnnLat, short for AnnotatedLatex, allows a concept to create 
+# step-by-step solutions with text, latex, hints, more hints, and embedded prerequisite concepts. 
+# It also allows for the creation of questions with text, latex, hints, and suggestions.
+# The communication between the engine and the concepts is faciliated by AnnLat 
+# by the agreement that all communication from a concept back to the engine that is intended
+# to be displayed to the user is an AnnLat object.
+
+# An instance object maintains an array of objects to be presented on the screen together
+# with an array indicating the type of each object. The engine can then access both arrays 
+# and decide how to encode each object, and which ones to present on the screen.
+require 'json'
+require 'securerandom'
+
+
+public
+def my_json
+  self.to_s
+end
+
+def get_type(thing)
+  if thing.class.ancestors.include? Concept
+    :Concept
+  elsif thing.class.ancestors.include? Latex
+    :Latex
+  elsif thing.class.ancestors.include? AnnLat
+    :AnnLat
+  else
+    thing.class.to_s.to_sym
+  end
+end
+
+def which_types(stuff)
+  subtypes = []
+  stuff.each do |stuffoid|
+    subtypes.insert(-1, get_type(stuffoid))
+  end
+  subtypes
+end
+
+class AnnLat #just the scafolds, the idea is to implement this so it will support the example concepts
+
+  include Enumerable
+
+  attr_accessor :objects, :tags, :options
+  def initialize
+    @objects = []
+    @tags = []
+    @options = {}
+  end 
+
+  def each_with_symbols
+    @objects.each_with_index do |x,i|
+      yield(@objects[i][0],@tags[i][0])
+    end
+  end
+
+  def each
+    @objects.each {|x| yield(x)}
+  end
+
+  def +(x)
+    out=AnnLat.new
+    out.objects=self.objects+x.objects
+    out.tags=self.tags+x.tags
+    out
+  end
+
+  def add(*stuff) # adds stuff to the @objects array, in sequential order. 
+    arr1=[]
+    arr2=[]
+    stuff.flatten.each do |object|
+      case get_type(object)
+      when :Table
+        hash = {}
+        hash[:objects]=object.objects
+        hash[:types]=object.types
+        arr1 << hash
+        arr2 << :Table
+      #when :Image
+      #  str = object.path
+      #  arr1 << str
+      #  arr2 << get_type(object)
+      else
+        arr1 << object
+        arr2 << get_type(object)
+      end
+
+    end
+    @objects << arr1
+    @tags << arr2
+    self
+  end
+
+  #hint is new AnnLat object that is passed with tag :Hint
+  def addHint(*stuff)
+    x=AnnLat.new
+    x.add(*stuff)
+    @objects << [x]
+    @tags << [:Hint]
+    self
+  end
+
+  def my_json
+    output={} 
+    obs=[]
+    tags=[]
+    @objects.each_with_index do |array, external_index|
+      arr=[]
+      tags_arr = []
+      array.each_with_index do |object, index|
+        tag=@tags[external_index][index]
+        unless tag == :Hint
+          arr << object.my_json
+          tags_arr << tag
+        end
+      end  
+      obs << arr unless arr == []
+      tags << tags_arr unless arr == []
+    end
+    output[:objects]=obs
+    output[:tags]=tags
+    output[:options]=@options
+    output
+  end
+ 
+  #returns all the hints — an array of AnnLat objects
+  def hints
+    output = []
+    @objects.each_with_index do |hint, index|
+      if @tags[index] == [:Hint]
+        output << hint[0]
+      end
+    end
+    output
+  end
+
+end
+
+class String 
+  def my_json
+    self
+  end
+end
+
+class Latex
+  def my_json
+    latex
+  end
+end
+
+class Image
+  attr_accessor :path    
+  attr_reader :uuid
+  attr_reader :options
+
+
+  def initialize(path, options={:dynamic => true})
+    @options=options
+    @path=path
+    @uuid=SecureRandom.uuid
+  end
+
+  def my_json
+    path
+  end
+
+end
+
+class Hash
+  def my_json
+    if self[:objects] and self[:types]
+      hash={}
+      hash[:objects] = self[:objects].map {|row| row.map {|cell| cell.my_json }}
+      hash[:types]=self[:types]
+      hash
+    end
+  end
+end
+
+#this class represents a table, it's just a two-dimensional array, [[a,x,f],[q]]
+class Table
+  include Enumerable
+  attr_accessor :objects, :types
+
+  def my_json
+    t=Table.new
+    t.objects = self.objects.map {|row| row.map {|cell| cell.my_json }}
+    t.types=self.types
+    t
+  end
+
+  def initialize
+    @objects=[]
+    @types=[]
+  end
+
+  def each
+    @objects.each {|row| yield(row)}
+  end
+
+  alias_method :each_row, :each
+end
+
+class Array
+
+  def to_table
+  #  raise "It must be two-dimensional array" unless self.depth==2
+    table=Table.new
+    self.each_with_index do |row,i|
+      table.objects[i]=row
+      temp=[]
+      row.each do |item|
+        temp << get_type(item)
+      end
+      table.types[i]=temp
+    end
+    table
+  end
+
+
+  #depth of an array
+  def depth
+  return 0 if self.class != Array
+  result = 1
+  self.each do |sub_a|
+    if sub_a.class == Array
+      dim = sub_a.depth
+      result = dim + 1 if dim + 1 > result
+    end
+  end
+  result
+  end
+
+end
+

data/lib/annlat/Concept.rb

@@ -0,0 +1,39 @@
+class Concept
+
+  def self.name
+    nil
+  end
+
+  def self.version
+    0
+  end
+
+  def solve
+    nil
+  end
+
+  def validate(attempt)
+   attempt.to_f == solve.to_f
+  end
+
+  def showQuestion
+    nil 
+  end
+
+  def showAnswer
+    nil
+  end
+
+  def showHow
+    nil
+  end
+
+  def self.whichConcepts
+    nil
+  end
+
+  def variants
+    nil
+  end
+end
+

data/lib/annlat/LaRuby.rb

@@ -0,0 +1,288 @@
+class Latex
+  def wrap
+    Wrapped.new(self)
+  end
+
+  def latex
+    ""
+  end
+
+  def to_ltx
+    self
+  end
+
+  alias_method :l, :to_ltx
+
+  def is(y)
+    LatexConsec.new(self, '=', y)
+  end
+
+  def ne(y)
+    LatexConsec.new(self, '\ne ', y)
+  end
+
+  def of(*args)
+    Func.new(self, *args)
+  end
+
+  def +(y)
+    Sum.new(self, y)
+  end
+
+  def -@
+    kind_of? Negative ? expr : Negative.new(self)
+  end
+
+  def -(y)
+    Sum.new(self, -y)
+  end
+
+  def *(y)
+    Product.new(self, y)
+  end
+
+  def /(y)
+    Frac.new(self, y)
+  end
+
+  def **(y)
+    Expon.new(self, y)
+  end
+
+  def glue(some_expr)
+    LatexConsec.new(self, some_expr)
+  end
+
+end
+
+class Func < Latex # represents @name(@args)
+  def initialize(some_name, *some_args)
+    @name = some_name.to_ltx
+    @args = some_args.map{|a| a.to_ltx}  
+  end
+
+  def latex
+    return (@name.latex + '()') if @args.length == 0
+    str = @args[0].latex
+    @args[1..-1].each {|a| str += (',' + a.latex)}
+    @name.latex + '(' + str + ')'
+  end
+end
+
+class Wrapped < Latex   # should add support for custom wrappings
+  def initialize(some_expr) 
+    @wrapee = some_expr.to_ltx 
+  end
+
+  def unwrap
+    @wrapee
+  end
+
+  def latex
+    '(' + @wrapee.latex + ')'
+  end
+end
+
+class Negative < Latex     # represents -@expr
+  attr_reader :expr
+  def initialize(some_expr) 
+    @expr = some_expr.to_ltx 
+    (@expr = @expr.wrap) if (@expr.kind_of?(Sum))
+  end
+
+  def latex
+    '-' + @expr.latex
+  end
+end
+
+class Atom < Latex
+  def initialize(some_expr)
+    @expr = some_expr.to_s
+  end
+
+  def latex
+    @expr
+  end
+end
+
+class LatexConsec < Latex
+  def initialize(*some_parts)
+    @parts = some_parts.map{|i| i.to_ltx}
+  end
+
+  def latex
+    @parts.map{|i| i.latex}.join
+  end
+end
+
+class BinOpe < Latex
+  attr_reader :args
+  attr_reader :oper
+
+  def initialize(some_oper, *some_args)
+    @oper = some_oper.to_ltx
+    some_args.map!(&:to_ltx)
+    first = some_args[0]
+    rest = some_args[1..-1].map {|a| (a.kind_of?(BinOpe) and a.args[0].kind_of?(Negative)) ? a.wrap : a }
+    @args = [first] + rest
+  end
+
+  def latex
+    @args.map{|a| a.latex}.join(@oper.latex)
+  end
+end
+
+class AssocBinOpe < BinOpe
+  def initialize(some_oper, *some_args) 
+    super(some_oper, *(some_args.map{|a| (a.kind_of?(AssocBinOpe) and (a.oper == @oper))? a.args : a}.flatten))
+  end
+
+  def latex() 
+    @args.map{|i| i.latex}.join(@oper.latex)
+ end
+end
+
+class Product < AssocBinOpe
+  def initialize(*some_factors)
+    super(Times, *some_factors)
+    @args.map!{|a| (a.kind_of?(Negative) or a.kind_of?(Sum))? a.wrap : a}
+  end  
+end
+
+class Sum < Latex
+  def initialize(*some_summands)
+    @summands = some_summands.map(&:to_ltx)
+  end
+
+  def latex 
+    str = @summands[0].latex
+    @summands[1..-1].each{|a| a.kind_of?(Negative) ? str += (a.latex) : str += ('+' + a.latex)}
+    str
+  end
+end
+
+class Frac < Latex
+  def initialize(some_numer, some_denom)
+    @numer = some_numer.to_ltx
+    @denom = some_denom.to_ltx
+  end
+
+  def latex
+    '\frac{' + @numer.latex + '}{' + @denom.latex + '}'
+  end
+end
+
+class Expon < Latex
+  def initialize(some_base, some_exp)
+    @base = some_base.to_ltx
+    @exp = some_exp.to_ltx
+  end
+
+  def latex
+    the_base = @base.wrap if (@base.kind_of?(Expon) or @base.kind_of?(Negative) or @base.kind_of?(BinOpe))
+    the_base.latex + '^{' + @exp.latex +  '}'
+  end
+end
+
+class Fixnum
+  def to_ltx
+    (self >= 0) ? Atom.new(self) : -(Atom.new(-self))
+  end
+
+  alias_method :l, :to_ltx
+end
+
+class Float
+  def to_ltx
+    (self >= 0) ? Atom.new(self) : -(Atom.new(-self))
+  end
+
+  alias_method :l, :to_ltx
+end
+
+class String
+  def to_ltx
+    Atom.new(self)
+  end
+
+  alias_method :l, :to_ltx
+end
+
+class LatexList < Atom
+  def initialize(arr)
+    @list = arr
+  end
+  
+  def latex
+    "(" + @list.join(", ") + ")"
+  end
+end
+
+class Array
+  def to_ltx
+    a = map{ |obj| obj.to_ltx.latex }
+    LatexList.new(a)
+  end
+end
+
+class LatexSet < Atom
+  def initialize(s)
+    @set = s.to_a
+  end
+  
+  def latex
+    "{" + @set.join(", ") + "}"
+  end
+end
+
+class Set
+  def to_ltx
+    s = map{ |obj| obj.to_ltx.latex }
+    LatexSet.new(s)
+  end
+end
+
+
+Plus = Atom.new('+')
+Times = Atom.new('\cdot ')
+Minus = Atom.new('-')
+
+#      Greek alphabet
+def alpha() Atom.new('\alpha ') end
+def beta() Atom.new('\beta ') end
+def gamma() Atom.new('\gamma ') end
+def delta() Atom.new('\delta ') end
+def epsilon() Atom.new('\epsilon ') end
+def varepsilon() Atom.new('\varepsilon ') end
+def zeta() Atom.new('\zeta ') end
+def eta() Atom.new('\eta ') end
+def theta() Atom.new('\theta ') end
+def vartheta() Atom.new('\vartheta ') end
+def kappa() Atom.new('\kappa ') end
+def mu() Atom.new('\mu ') end
+def nu() Atom.new('\nu ') end
+def xi() Atom.new('\xi ') end
+def pi() Atom.new('\pi ') end
+def varpi() Atom.new('\varpi ') end
+def rho() Atom.new('\rho ') end
+def varrho() Atom.new('\varrho ') end
+def sigma() Atom.new('\sigma ') end
+def varsigma() Atom.new('\varsigma ') end
+def tau() Atom.new('\tau ') end
+def upsilon() Atom.new('\upsilon ') end
+def phi() Atom.new('\phi ') end
+def varphi() Atom.new('\varphi ') end
+def chi() Atom.new('\chi ') end
+def psi() Atom.new('\psi ') end
+def omega() Atom.new('\omega ') end
+def cGamma() Atom.new('\Gamma ') end
+def cDelta() Atom.new('\Delta ') end
+def cTheta() Atom.new('\Theta ') end
+def cLambda() Atom.new('\Lmabda ') end
+def cXi() Atom.new('\Xi ') end
+def cPi() Atom.new('\Pi ') end
+def cSigma() Atom.new('\Sigma ') end
+def cUpsilon() Atom.new('\Upsilon ') end
+def cPhi() Atom.new('\Phi ') end
+def cPsi() Atom.new('\Psi ') end
+def cOmega() Atom.new('\Omega ') end

data/lib/annlat/Sundries.rb

@@ -0,0 +1,72 @@
+def final?
+  instance_methods(false).include? :showHow
+end
+
+public :final?
+
+class Fixnum
+  def prettify
+    self
+  end
+end
+
+class Float
+  def prettify
+    to_i == self ? to_i : self
+  end
+end
+
+class Rational
+  def prettify
+    if self.denominator==1
+      self.numerator 
+    else
+      self
+    end
+  end
+end
+
+class Concept
+
+  attr_accessor :images
+  attr_accessor :uuid
+
+
+  def move_image(img)
+      uuid=img.uuid
+      path=img.path
+      if !img.options[:dynamic]
+        begin
+          FileUtils.mv("engine/concepts/#{path}", "public/images/#{self.class}/static/#{path}")
+        rescue Errno::ENOENT
+        end
+        img.path = "#{self.class}/static/#{path}"
+      else
+        img.path= "#{self.class}/#{uuid}"
+        FileUtils.mv("#{path}", "public/images/#{self.class}/#{uuid}")
+      end    
+      img
+  end
+
+  def move_images
+    concept=self
+    @images=[] if @images.nil?
+    begin
+      Dir.mkdir("public/images/#{self.class}")
+    rescue Errno::EEXIST
+    end
+    begin
+      Dir.mkdir("public/images/#{self.class}/static")
+    rescue Errno::EEXIST
+    end
+    @images.map {|x| move_image(x)}
+  end
+
+  def addImage(img)
+    @images=[] if @images.nil?
+    raise "You tried to add not an image" if img.class!=Image
+    @images << img
+  end
+
+
+end

data/lib/annlat/version.rb

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

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: annlat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexander Shevtsov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: ''
+email:
+- randomlogin76@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- annlat.gemspec
+- lib/annlat.rb
+- lib/annlat/AnnLat.rb
+- lib/annlat/Concept.rb
+- lib/annlat/LaRuby.rb
+- lib/annlat/Sundries.rb
+- lib/annlat/version.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Learnleague gem for containg used libraries
+test_files: []