q-language 1.0.0

data/lib/q-language/methods/true.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+# 
+# Copyright © 2010-2011 Jesse Sielaff
+# 
+
+class QTrue < QObject
+  def stringify
+    "true"
+  end
+  
+  def true?
+    true
+  end
+end

data/lib/q-language/node.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+# 
+# Copyright © 2010-2011 Jesse Sielaff
+# 
+
+class Q_Node
+  def initialize (node_type, name, klass, string, nodes)
+    @node_type = node_type
+    
+    @value = case
+      when name then name
+      when klass then Object.const_get(:"Q#{klass}").from_s(string)
+      when nodes then nodes.each {|node| node.instance_variable_set(:@block, self) }
+    end
+  end
+  
+  attr_reader :node_type, :value
+  
+  # • User method
+  # Returns the block that contains the Node.
+  # 
+  def block
+    @block
+  end
+  
+  # • User method
+  # Returns an Array of the block Node's contents. If the Node is not a block,
+  # returns nil.
+  # 
+  def nodes
+    @value if @node_type == :block
+  end
+  
+  # • User method
+  # Returns a String representing the Node in Q script format.
+  # 
+  def to_script
+    case @node_type
+      when :block then "{#{@value.map {|n| n.to_script }.join ?\ }}"
+      when :literal then "#{@value.to_qliteral}"
+      when :method then "#@value"
+      when :variable then ":#@value"
+    end
+  end
+end

data/lib/q-language/object.rb

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+# 
+# Copyright © 2010-2011 Jesse Sielaff
+# 
+
+class Q_Object
+  def initialize (value)
+    @__value__ = value
+  end
+  
+  Subclasses = []
+  
+  %w:class dup extend hash nil? send:.each {|name| undef_method name }
+  
+  # • User method
+  # Returns the Q_Environment in which the Q_Object is operating.
+  # 
+  def env
+    @__environment__
+  end
+  
+  # Returns the Q_Object.
+  # 
+  def to_q
+    self
+  end
+  
+  # Returns the Q literal string for the Q_Object's internally-stored ruby
+  # value.
+  # 
+  def to_qliteral
+    value.to_qliteral
+  end
+  
+  # • User method
+  # Returns the Q_Object's internally-stored ruby value.
+  # 
+  def value
+    @__value__
+  end
+  
+  # Adds the subclass to the Q_Object::Subclasses array.
+  # 
+  def Q_Object.inherited (subclass)
+    Subclasses << subclass
+    subclass.const_set(:MethodArguments, {})
+  end
+  
+  # Adds a key-value pair to the MethodArguments hash for the current Class. The
+  # key is the new method name. The value is a Hash containing a :reqs_left
+  # Array and a :reqs_right Array, each of which contains one Q class per item
+  # from the left or right side of the queue that will be passed as an argument
+  # to the new method. If the Hash contains a {block: true} key-value pair, the
+  # new method requires a block argument. If the Hash contains a {splat: qclass}
+  # key-value pair, the new method will be passed all items of that Q class from
+  # the queue as a splat argument.
+  # 
+  def Q_Object.method_added (name)
+    # For compatibility with Ruby < 1.9.2
+    return unless UnboundMethod.public_method_defined? :parameters
+    
+    method_args = self::MethodArguments[name] = { reqs_left: [], reqs_right: [] }
+    
+    instance_method(name).parameters.each do |arg_type, object_type|
+      case arg_type
+        when :block then method_args[:block] = true
+        when :rest then method_args[:splat] = (object_type) ? const_get(:"Q#{class_name(object_type)}") : nil
+        when :req then (method_args.has_key?(:splat) ? method_args[:reqs_right] : method_args[:reqs_left]) << const_get(:"Q#{class_name(object_type)}")
+      end
+    end
+    
+    # Splat arg serves as a divider:
+    # 
+    # def foo (number, *, string)
+    #    Args to the left come from the start of the queue;
+    #    args to the right come from the end of the queue.
+    #    The rest of the objects are left in the queue.
+    # 
+    # def foo (number, *every_number, number)
+    #    If a type name is given to the splat arg, it grabs
+    #    every object of that type (except as needed by the
+    #    required args).
+  end
+  
+  # Returns an Array of the unique names of every method defined in a Q class.
+  # 
+  def Q_Object.method_names
+    Subclasses.inject([]) {|ary, klass| ary | klass::MethodArguments.keys }
+  end
+  
+  # Returns the class name corresponding to the given argument type string.
+  # Strips preceding 'every_' and trailing '_{number}'. For example, 'string'
+  # and 'string_2' result in 'String', 'some_class' results in 'SomeClass', and
+  # 'every_number' results in 'Number'.
+  # 
+  def Q_Object.class_name (arg_type)
+    arg_type.to_s
+      .capitalize
+      .gsub(/_[0-9]+$/,'')
+      .gsub(/(?:^|_|([0-9]))(.)/) { "#{$1}#{$2.upcase}" }
+      .gsub(/^Every/,'')
+  end
+end
+
+QObject = Class.new(Q_Object)
+QArray, QBlock, QDynamic, QFalse,
+QHash, QModule, QNil, QNumber,
+QString, QTime, QToken, QTrue =
+  *12.times.map { Class.new(QObject) }
+QClass = Class.new(QModule)
+
+Object.send(:define_method, :to_q) { Object.const_get(:"Q#{self.class}").new(self) }
+FalseClass.send(:define_method, :to_q) { QFalse.new(false) }
+NilClass.send(:define_method, :to_q) { QNil.new(nil) }
+Numeric.send(:define_method, :to_q) { QNumber.new(Number(self)) }
+Proc.send(:define_method, :to_q) { QBlock.new(self) }
+Symbol.send(:define_method, :to_q) { QToken.new(self) }
+TrueClass.send(:define_method, :to_q) { QTrue.new(true) }
+
+Object.send(:define_method, :to_qliteral) { "#{self.class}(#{self})" }
+FalseClass.send(:define_method, :to_qliteral) { "false" }
+NilClass.send(:define_method, :to_qliteral) { nil }
+Numeric.send(:define_method, :to_qliteral) { "Number(#{Number(self)})" }
+Symbol.send(:define_method, :to_qliteral) { "Token(#{self})" }
+TrueClass.send(:define_method, :to_qliteral) { "true" }

data/lib/q-language/parser.rb

@@ -0,0 +1,104 @@
+# encoding: UTF-8
+# 
+# Copyright © 2010-2011 Jesse Sielaff
+# 
+
+require 'racc/parser'
+require 'strscan'
+
+class Q_Parser < Racc::Parser
+  def initialize (script)
+    @ss = StringScanner.new(script)
+  end
+  
+  # Removes and returns one item from the Array of script tokens.
+  # Required by racc.
+  # 
+  def next_token
+    @tokens.shift
+  end
+  
+  # Raises a SyntaxError.
+  # Required by racc.
+  # 
+  def on_error (*)
+    raise SyntaxError, "tokens do not form valid script"
+  end
+  
+  # Parses the Q script, then returns an Array containing the outermost Node, an
+  # Array of every block Node, an Array of every literal Node, an Array of every
+  # method Node, and an Array of every variable Node. If any invalid tokens are
+  # encountered in the script or if the tokens do not form a valid Q script,
+  # raises a SyntaxError.
+  # 
+  def parse
+    @tokens = []
+    @ss.reset
+    
+    until @ss.eos?
+      @tokens << case c = @ss.getch
+        when /\s/ then next
+        when /[\p{alpha}_]/
+          @ss.unscan.scan /[\p{alnum}_]+[?!]?/
+          [:ID, @ss.matched.intern]
+        when /[}:{]/ then [c, 0]
+        when /\(/ then [:STRING, scan_literal]
+        else raise SyntaxError, "script contains invalid token `#{c}'"
+      end
+    end
+    
+    @tokens << [false, false]
+    
+    @blocks = []
+    @literals = []
+    @methods = []
+    @variables = []
+    
+    return do_parse, @blocks, @literals, @methods, @variables
+  end
+  
+  # Returns the string enclosed by the set of parentheses beginning at the '('
+  # exactly one character before the StringScanner's current pointer location
+  # and ending at the ')' character after all sets of parentheses have been
+  # balanced. Parenthesis characters escaped by a preceding '\' are not
+  # considered in the balance count. If the end of the string is reached before
+  # the closing ')' character, raises a SyntaxError.
+  # 
+  def scan_literal
+    strings = []
+    p_count = 0
+    
+    while s = @ss.scan_until(/(?=[()\\])/)
+      case (c = @ss.getch).ord
+        when 41 then (p_count == 0) ? (return (strings << s).join) : (p_count -= 1) # )
+        when 40 then p_count += 1 # (
+        when 92 then %w[) (].include?(@ss.peek(1)) ? (strings << s << c << @ss.getch) : (next) # \
+      end
+      
+      strings << s << c
+    end
+    
+    raise SyntaxError, "unterminated literal meets end of script"
+  end
+  
+  Racc_debug_parser = false
+  Racc_arg = [
+    [2,9,6,7,2,10,6,7,2,3,12,13], [2,3,2,2,4,4,4,4,0,1,6,7],
+    [-9,-9,-8,-9,-9,-2,-9,-5,-6,14,-1,-7,-3,-4],
+    [6,9,-2,1,2,nil,5,5,nil,nil,nil,nil,nil,nil],
+    [8,4,11,1], [3,2,3,1], [nil,5,nil,nil], [nil,3,-1,-2], 7,
+    [0,0,:racc_error, 3,8,:new_block, 1,10,:block,
+      2,10,:new_variable, 2,10,:new_literal, 1,10,:new_method,
+      1,9,:new_node_array, 2,9,:append_node, 0,9,:new_empty_array],
+    { false=>0, error: 1, "{"=>2, "}"=>3, ":"=>4, ID: 5, STRING: 6 },
+    14, 9, true]
+  
+  define_method(:append_node) {|v,*| v[0] << v[1] }
+  define_method(:block) {|v,*| v[0] }
+  define_method(:new_block) {|v,*| @blocks[0...0] = Q_Node.new(:block, nil, nil, nil, v[1]) }
+  define_method(:new_literal) {|v,*| @literals[0...0] = Q_Node.new(:literal, nil, v[0], v[1], nil) }
+  define_method(:new_method)  {|v,*| @methods[0...0] = Q_Node.new(:method, v[0], nil, nil, nil) }
+  define_method(:new_variable) {|v,*| @variables[0...0] = Q_Node.new(:variable, v[1], nil, nil, nil) }
+  define_method(:new_node_array) {|v,*| [v[0]] }
+  define_method(:new_empty_array) {|v,*| [] }
+end

data/lib/q-language/writer.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+# 
+# Copyright © 2010-2011 Jesse Sielaff
+# 
+
+class Q_Writer
+  # • User method
+  # Returns a String representing a random block of Q script.
+  # 
+  def generate (remaining_depth = self.nesting)
+    b = 0...weight[:block]
+    l = b.end...(b.end + weight[:literal])
+    m = l.end...(l.end + weight[:method])
+    v = m.end...(m.end + weight[:variable])
+    
+    strings = nodes.times.map do
+      case rand(v.end)
+        when b then (remaining_depth > 0) ? generate(remaining_depth - 1) : redo
+        when l then literals.sample.to_qliteral
+        when m then methods.sample
+        when v then (x = variables.sample) ? ":#{x}" : ()
+      end
+    end
+    
+    "{#{strings.compact.join ?\ }}"
+  end
+  
+  # • User method
+  # Returns "Q".
+  # 
+  def language
+    ?Q
+  end
+  
+  # • User method
+  # Sets the Array of literals to be sampled from when generating a random
+  # block, then returns the Q_Writer. If no argument is given, returns the
+  # current literals Array. Default value is [-1,0,1,2,5,10,'abc',:foo,:bar].
+  # 
+  def literals (literals = nil)
+    literals ? (@literals = literals; self) : (@literals ||= [-1,0,1,2,5,10,'abc',:foo,:bar])
+  end
+  
+  # • User method
+  # Sets the Array of methods to be sampled from when generating a random block,
+  # then returns the Q_Writer. If no argument is given, returns the current
+  # methods Array. Default value is the Array of all available Q methods.
+  # 
+  def methods (methods = nil)
+    methods ? (@methods = methods.map(&:to_sym); self) : (@methods ||= Q_Object.method_names)
+  end
+  
+  # • User method
+  # Sets the maximum depth of nested blocks in a random script, then returns the
+  # Q_Writer. If no argument is given, returns the current maximum depth of
+  # nesting. Default value is 5.
+  # 
+  def nesting (nesting = nil)
+    nesting ? (@nesting = nesting.to_int; self) : (@nesting ||= 5)
+  end
+  
+  # • User method
+  # Sets the maximum number of nodes per block in a random script, then returns
+  # the Q_Writer. A block node counts as only 1 node, ignoring the nodes inside
+  # the block. If no argument is given, gives the current maximum nodes per
+  # block. Default value is 7.
+  # 
+  def nodes (nodes = nil)
+    nodes ? (@nodes = nodes.to_int; self) : (@nodes ||= 7)
+  end
+  
+  # • User method
+  # Sets the Array of variables to be sampled from when generating a random
+  # block, then returns the Q_Writer. If no argument is given, returns the
+  # current variables Array. Default value is [:i,:j,:k,:l,:m,:n,:w,:x,:y,:z].
+  # 
+  def variables (variables = nil)
+    variables ? (@variables = variables.map(&:to_sym); self) : (@variables ||= %w:i j k l m n w x y z:.map(&:to_sym))
+  end
+  
+  # • User method
+  # Sets the relative frequency with which each node type will appear when
+  # generating a random block, then returns the Q_Writer. If no argument is
+  # given, returns the current node weight. Default values are block: 1,
+  # literal: 1, method: 1, variable: 1.
+  # 
+  def weight (weight = nil)
+    weight ? (@weight = weight.to_hash.select {|k,v| [:block, :literal, :method, :variable].include?(k) && v.is_a?(Fixnum) }; @weight.default = 1; self) : (@weight ||= {block: 1, literal: 1, method: 1, variable: 1})
+  end
+end

data/test/methods/test_array.rb

@@ -0,0 +1,191 @@
+# encoding: UTF-8
+# 
+# Copyright © 2010-2011 Jesse Sielaff
+# 
+
+require_relative '../test.rb'
+
+class TestArray < TestQ
+  def test_add_returns_array_concatenation
+    eq [1,1,2,2], "{ { one one numbers } add { two two numbers } }"
+  end
+  
+  def test_add_all_returns_array_concatenation
+    eq [1,1,2,2,[]], "{ { one one numbers } { two two numbers } { array arrays } add_all }"
+  end
+  
+  def test_array_p_returns_self
+    returns :a, "{ :a array array? }"
+  end
+  
+  def test_at_n_returns_nth_element
+    eq 2, "{ two one zero numbers at zero }"
+  end
+  
+  def test_at_outside_of_range_returns_nil
+    eq nil, "{ two one zero numbers at Number(100) }"
+  end
+  
+  def test_clear_returns_empty_array
+    eq [], "{ one two numbers clear }"
+  end
+  
+  def test_clear_returns_same_array
+    returns :a, "{ one two :a numbers clear }"
+  end
+  
+  def test_combination_returns_self
+    returns :a, "{ zero pi i e :a numbers combination two { } }"
+  end
+  
+  def test_combination_calls_block_once_per_combination
+    eq 6, "{ zero pi i e numbers combination two { :a push i } :a elect length }", a: []
+  end
+  
+  def test_combination_terminates_upon_break
+    eq 1, "{ zero pi i e numbers combination two { :a push i break_if { true } } :a elect length }", a: []
+  end
+  
+  def test_combination_continues_upon_jump
+    eq 6, "{ zero pi i e numbers combination two { :a push i jump_if { true } :a elect push i } :a elect length }", a: []
+  end
+  
+  def test_combination_terminates_upon_break
+    eq 1, "{ zero pi i e numbers combination two { :a push i break_if { true } } :a elect length }", a: []
+  end
+  
+  def test_combination_calls_block_with_each_combination_as_argument
+    eq [[0,1],[0,2],[1,2]], "{ zero one two numbers combination two :c { :a push :c } :a elect }", a: []
+  end
+  
+  def test_compact_returns_array_of_all_non_nil_items_in_array
+    eq [1,2], "{ one nil two objects compact }"
+  end
+  
+  def test_compact_bang_returns_same_array
+    returns :a, "{ one nil two :a objects compact! }"
+  end
+  
+  def test_compact_bang_removes_nils_from_array
+    eq [1,2], "{ one nil two objects compact! }"
+  end
+  
+  def test_concat_returns_same_array
+    returns :a, "{ { one two :a numbers } concat { zero one numbers } }"
+  end
+  
+  def test_concat_returns_array_concatenation
+    eq [1,2,0,1], "{ { one two numbers } concat { zero one numbers } }"
+  end
+  
+  def test_count_returns_number_of_matching_objects_in_array
+    eq 3, "{ nil Token(a) nil Token(b) nil objects nil count }"
+  end
+  
+  #######################
+  def test_count_by
+  end
+  
+  def test_cycle
+  end
+  
+  def test_cycle_n
+  end
+  #######################
+  
+  def test_delete_returns_deleted_object
+    eq :b, "{ Token(a) Token(b) Token(c) tokens delete Token(b) }"
+  end
+  
+  def test_delete_returns_nil_if_array_does_not_contain_object
+    eq nil, "{ Token(a) Token(b) Token(c) tokens delete Token(d) }"
+  end
+  
+  def test_delete_removes_all_instances_of_deleted_object_from_array
+    eq [2], "{ one one two :a numbers delete one :a elect }"
+  end
+  
+  def test_delete_at_returns_deleted_object
+    eq :c, "{ Token(a) Token(b) Token(c) tokens delete_at two }"
+  end
+  
+  def test_delete_at_returns_nil_if_index_is_out_of_range
+    eq nil, "{ Token(a) Token(b) Token(c) tokens delete_at Number(100) }"
+  end
+  
+  def test_delete_at_removes_object_at_index_from_array
+    eq [0, 2], "{ zero pi two :a numbers delete_at one :a elect }"
+  end
+  
+  def test_delete_if_returns_self
+    returns :a, "{ zero one two :a numbers delete_if { } }"
+  end
+  
+  def test_delete_if_calls_block_once_per_element
+    eq 3, "{ zero one two numbers delete_if { :a push i } :a elect length }", a: []
+  end
+  
+  def test_delete_if_terminates_upon_break
+    eq 1, "{ zero one two numbers delete_if { :a push i break_if { true } } :a elect length }", a: []
+  end
+  
+  def test_delete_if_continues_upon_jump
+    eq 3, "{ zero one two numbers delete_if { :a push i jump_if { true } :a elect push i } :a elect length }", a: []
+  end
+  
+  def test_delete_if_terminates_upon_break
+    eq 1, "{ zero one two numbers delete_if { :a push i break_if { true } } :a elect length }", a: []
+  end
+  
+  def test_delete_if_calls_block_with_each_element_as_argument
+    eq [2,3,4], "{ zero one two numbers delete_if :c { :a push { :c add two } } :a elect }", a: []
+  end
+  
+  def test_delete_if_removes_element_from_array_when_block_returns_true
+    eq [], "{ :a delete_if :c { true } }", a: [1,2,3]
+  end
+  
+  def test_delete_if_does_not_remove_element_from_array_when_block_returns_false
+    eq [1,3], "{ :a delete_if :c { :c eq? two } }", a: [1,2,3]
+  end
+  
+  def test_drop_returns_array_of_elements_without_first_n_elements
+    eq [3,4,5], "{ :a drop two }", a: [1,2,3,4,5]
+  end
+  
+  def test_drop_returns_array_of_all_elements_when_n_is_negative
+    eq [1,2,3,4,5], "{ :a drop negative two }", a: [1,2,3,4,5]
+  end
+  
+  def test_drop_while_calls_block_once_per_element
+    eq 3, "{ zero one two numbers drop_while { true :a push i } :a elect length }", a: []
+  end
+  
+  def test_drop_while_terminates_if_block_returns_false
+    eq 1, "{ zero one two numbers drop_while { false { :a push i } } :a elect length }", a: []
+  end
+  
+  def test_drop_while_terminates_upon_break
+    eq 1, "{ zero one two numbers drop_while { :a push i break_if { true } } :a elect length }", a: []
+  end
+  
+  def test_drop_while_continues_upon_jump
+    eq 3, "{ zero one two numbers drop_while { false { :a push i } jump_if { true } { :a elect push i } } :a elect length }", a: []
+  end
+  
+  def test_delete_if_terminates_upon_break
+    eq 1, "{ zero one two numbers delete_if { :a push i break_if { true } } :a elect length }", a: []
+  end
+  
+  def test_delete_if_calls_block_with_each_element_as_argument
+    eq [2,3,4], "{ zero one two numbers delete_if :c { :a push { :c add two } } :a elect }", a: []
+  end
+  
+  def test_delete_if_removes_element_from_array_when_block_returns_true
+    eq [], "{ :a delete_if :c { true } }", a: [1,2,3]
+  end
+  
+  def test_delete_if_does_not_remove_element_from_array_when_block_returns_false
+    eq [1,3], "{ :a delete_if :c { :c eq? two } }", a: [1,2,3]
+  end
+end