tickly 0.0.3 → 0.0.4

data/lib/tickly/evaluator.rb

@@ -18,7 +18,8 @@ module Tickly
         handler_class = @node_handlers.find{|e| unconst_name(e) == expr[0]}
         handler_arguments = expr[1]
         hash_of_args = {}
-        expr[1].map do | e |
+        # Use 1..-1 to skip the curly brace symbol
+        expr[1][1..-1].map do | e |
           # The name of the command is the first element, always
           hash_of_args[e[0]] = e[1]
         end
@@ -41,7 +42,7 @@ module Tickly
     end
     
     def has_subcommand?(expr)
-      expr[1].is_a?(LiteralExpr)
+      expr[1][0] == :c
     end
   end
 end

data/lib/tickly/node_extractor.rb

@@ -0,0 +1,22 @@
+module Tickly
+  # A more refined version of the Parser class that can scope itself to the passed Nuke node
+  # classnames. It will toss all of the node data that is not relevant, keeping only nodes that are
+  # required.
+  class NodeExtractor < Parser
+    def initialize(*interesting_node_class_names)
+      @nodes = interesting_node_class_names
+    end
+    
+    # Override this to remove any unneeded subexpressions
+    def expand_subexpr!(expr, at_depth)
+      if is_node_constructor?(expr, at_depth)
+        node_class_name = expr[0]
+        expr.replace([:discarded]) unless @nodes.include?(node_class_name)
+      end
+    end
+    
+    def is_node_constructor?(expr, depth)
+      depth == 1 && expr[0].is_a?(String) && expr.length == 2 && expr[1][0] == :c
+    end
+  end
+end

data/lib/tickly/parser.rb

@@ -3,14 +3,18 @@ require 'stringio'
 module Tickly
   
   class Parser
-
+    
     # Parses a piece of TCL and returns it converted into internal expression
-    # structures (nested StringExpr or LiteralExp objects).
+    # structures (nested StringExpr or LiteralExpr objects).
     def parse(io_or_str)
       io = io_or_str.respond_to?(:read) ? io_or_str : StringIO.new(io_or_str)
       sub_parse(io)
     end
     
+    # Override this to remove any unneeded subexpressions
+    def expand_subexpr!(expr, at_depth)
+    end
+    
     private
     
     LAST_CHAR = -1..-1 # If we were 1.9 only we could use -1
@@ -19,55 +23,98 @@ module Tickly
     # or until the IO is exhausted. The last argument is the class used to
     # compose the subexpression being parsed. The subparser is reentrant and not
     # destructive for the object containing it.
-    def sub_parse(io, stop_char = nil, expr_class = LiteralExpr)
+    def sub_parse(io, stop_char = nil, stack_depth = 0)
       # A standard stack is an expression that does not evaluate to a string
-      stack = expr_class.new
+      stack = []
       buf = ''
+      last_char_was_linebreak = false
       until io.eof?
         char = io.read(1)
         
         if buf[LAST_CHAR] != ESC
           if char == stop_char # Bail out of a subexpr
             stack << buf if (buf.length > 0)
-            return cleanup(stack)
+            # Chip away the tailing linebreak if it's there
+            chomp!(stack)
+            return stack
           elsif char == " " || char == "\n" # Space
             if buf.length > 0
               stack << buf
               buf = ''
             end
             if char == "\n" # Introduce a stack separator! This is a new line
-              stack << nil
+              if stack.any? && !last_char_was_linebreak
+                last_char_was_linebreak = true
+                stack = handle_expr_terminator(stack, stack_depth)
+              end
             end
           elsif char == '[' # Opens a new string expression
             stack << buf if (buf.length > 0)
-            stack << sub_parse(io, ']', StringExpr)
+            last_char_was_linebreak = false
+            stack << [:b] + sub_parse(io, ']', stack_depth + 1)
           elsif char == '{' # Opens a new literal expression  
             stack << buf if (buf.length > 0)
-            stack << sub_parse(io, '}', LiteralExpr)
+            last_char_was_linebreak = false
+            stack << [:c] + sub_parse(io, '}', stack_depth + 1)
           elsif char == '"'
             stack << buf if (buf.length > 0)
+            last_char_was_linebreak = false
             stack << parse_str(io, '"')
           elsif char == "'"
             stack << buf if (buf.length > 0)
+            last_char_was_linebreak = false
             stack << parse_str(io, "'")
           else
+            last_char_was_linebreak = false
             buf << char
           end
         else
+          last_char_was_linebreak = false
           buf << char
         end
       end
     
       # Ramass any remaining buffer contents
       stack << buf if (buf.length > 0)
-    
-      cleanup(stack)
+      
+      # Handle any remaining subexpressions
+      if stack.include?(nil)
+        stack = handle_expr_terminator(stack, stack_depth)
+      end
+      # Chip awiy the trailing null
+      chomp!(stack)
+      
+      return stack
     end
     
-    private
-    
     ESC = 92.chr # Backslash (\)
     
+    def chomp!(stack)
+      stack.delete_at(-1) if stack.any? && stack[-1].nil?
+    end
+    
+    def handle_expr_terminator(stack, stack_depth)
+      # Figure out whether there was a previous expr terminator
+      previous_i = stack.index(nil)
+      # If there were none, just get this over with. Wrap the stack contents
+      # into a subexpression and carry on.
+      unless previous_i
+        subexpr = stack
+        expand_subexpr!(subexpr, stack_depth + 1)
+        return [subexpr] + [nil]
+      end
+      
+      # Now, if there was one, we are the next subexpr in line that just terminated.
+      # What we need to do is pick out all the elements from that terminator onwards
+      # and wrap them.
+      subexpr = stack[previous_i+1..-1]
+      
+      # Use expand_subexpr! to trim away any fat that we don't need
+      expand_subexpr!(subexpr, stack_depth + 1)
+      
+      return stack[0...previous_i] + [subexpr] + [nil]
+    end
+    
     def parse_str(io, stop_char)
       buf = ''
       until io.eof?
@@ -85,19 +132,5 @@ module Tickly
       return buf
     end
     
-    # Tells whether a passed object is a StringExpr or LiteralExpr
-    def expr?(something)
-      [StringExpr, LiteralExpr].include?(something.class)
-    end
-    
-    # Cleans up a subexpression stack. Currently it only removes nil objects
-    # in-between items (which act as line separators)
-    def cleanup(expr)
-      # Ensure multiple consecutive line breaks are ignored
-      no_multiple_breaks = Tickly.singularize_nils_in(expr)
-      # Convert line breaks into subexpressions
-      Tickly.split_array(no_multiple_breaks)
-    end
-  
   end
 end

data/lib/tickly.rb

@@ -1,70 +1,30 @@
 require File.dirname(__FILE__) + "/tickly/parser"
+require File.dirname(__FILE__) + "/tickly/node_extractor"
 require File.dirname(__FILE__) + "/tickly/evaluator"
 require 'forwardable'
 
 module Tickly
-  VERSION = '0.0.3'
-  
-  # Represents a TCL expression with it's arguments (in curly or square braces)
-  class Expr
-    extend Forwardable
-    
-    def_delegators :@e, :push, :<<, :any?, :reject!, :map!, :[], :delete_at, :include?, :each, :each_with_index, :empty?, :join, :length
-    
-    def initialize(elements = [])
-      @e = elements
-    end
-    
-    def map(&blk)
-      self.class.new(@e.map(&blk))
-    end
-    
-    def to_a
-      @e
-    end
-    
-    def ==(another)
-      another.to_a == to_a
-    end
-    
-    def inspect
-      @e.map{|e| e.inspect }.join(', ')
-    end
-    
-  end
-  
-  # Represents an expression between curly braces (within which no text substitution will be done)
-  # like  { 1 2 3 }
-  class LiteralExpr < Expr
-    def inspect
-      "le(%s)" % super
-    end
-  end
-
-  # Represents an expression between square brackets (where text substitution will be done)
-  # like  [1 2 3]
-  class StringExpr < Expr
-    def inspect
-      "se(%s)" % super
-    end
-  end
+  VERSION = '0.0.4'
   
   # Provides the methods for quickly emitting the LiteralExpr and StringExpr objects
   module Emitter
     def le(*elems)
-      LiteralExpr.new(elems)
+      [:c] + elems
+    end
+    
+    def e(*elems)
+      elems
     end
     
     def se(*elems)
-      LiteralExpr.new(elems)
+      [:b] + elems
     end
   end
   
-  
   def self.to_tcl(e)
-    if e.is_a?(Tickly::LiteralExpr)
+    if e.is_a?(Array) && e[0] == :c
       '{%s}' % e.map{|e| to_tcl(e)}.join(' ')
-    elsif e.is_a?(Tickly::StringExpr)
+    elsif e.is_a?(Array) && e[0] == :b
       '[%s]' % e.map{|e| to_tcl(e)}.join(' ')
     elsif e.is_a?(String) && (e.include?('"') || e.include?("'"))
       e.inspect
@@ -73,39 +33,5 @@ module Tickly
     end
   end
   
-  # Splits the passed Array-like object into sub-arrays of the same class,
-  # delimited by the passed separator. Note that when the separators occur at the beginning or at the end of
-  # the passed object they will be discarded
-  def self.split_array(arr, separator = nil)
-    return arr unless arr.include?(separator)
-    
-    subarrays = arr.class.new
-    subarrays.push(arr.class.new)
-    
-    arr.each_with_index do | element, i |
-      if element == separator && subarrays.length > 0 && subarrays[-1].any? && (i < (arr.length - 1))
-        subarrays.push(arr.class.new)
-      elsif element == separator
-        # toss it
-      else
-        subarrays[-1].push(element)
-      end
-    end
-    return subarrays
-  end
-  
-  # Removes consecutive nils from the passed Array-like object and returns a new one with all consecutive nils reduced
-  # to one nil
-  def self.singularize_nils_in(arr)
-    new_arr = arr.class.new
-    arr.each_with_index do | elem, i |
-      if elem.nil? && arr[i-1].nil? && i > 0
-        # pass
-      else
-        new_arr << elem
-      end
-    end
-    new_arr
-  end
   
 end

data/test/test-data/nuke_group.txt

@@ -16,4 +16,4 @@ Group {
  Output {
   name Output1
  }
-end_group
+end_group

data/test/test_evaluator.rb

@@ -16,7 +16,7 @@ class TestEvaluator < Test::Unit::TestCase
   end
   
   should "not send anything to the handler when the expr does not conform to the standard" do
-    stack = le("ShouldNotBeInstantiated")
+    stack = e("ShouldNotBeInstantiated")
     e = Tickly::Evaluator.new
     e.add_node_handler_class(ShouldNotBeInstantiated)
     assert_nothing_raised { e.evaluate(stack) }
@@ -29,8 +29,8 @@ class TestEvaluator < Test::Unit::TestCase
     end
   end
   
-  should "instantiate the handler class" do
-    stack = le("SomeNode", le(le("foo", "bar"), le("baz", "bad")))
+  def test_instantiates_handler_class
+    stack = e("SomeNode", le(e("foo", "bar"), e("baz", "bad")))
     e = Tickly::Evaluator.new
     e.add_node_handler_class(SomeNode)
     node = e.evaluate(stack)

data/test/test_node_extractor.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class TestNodeExtractor < Test::Unit::TestCase
+  
+  include Tickly::Emitter
+  
+  def test_parsing_nuke_script_with_indentations
+    f = File.open(File.dirname(__FILE__) + "/test-data/nuke_group.txt")
+    x = Tickly::NodeExtractor.new("Group")
+    
+    p = x.parse(f)
+    grp = e(
+      e("set", "cut_paste_input", se("stack", "0")),
+      e("version", "6.3", "v4"),
+      e("Group",
+        le(
+          e("inputs", "0"),
+          e("name", "Group1"),
+          e("selected", "true")
+          )
+        ),
+      e(:discarded),
+      e(:discarded),
+      e(:discarded),
+      e("end_group")
+    )
+    assert_equal grp, p
+  end
+  
+end

data/test/test_parser.rb

@@ -5,72 +5,65 @@ class TestParser < Test::Unit::TestCase
   include Tickly::Emitter
   
   should "parse a single int as a stack with a string" do
-    assert_kind_of Tickly::LiteralExpr, P.parse('2')
-    assert_equal le("2"), P.parse('2')
+    assert_equal e("2"), P.parse('2')
   end
 
   should "parse a single int and discard whitespace" do
     p = P.parse('   2 ')
-    assert_kind_of Tickly::LiteralExpr, p
-    assert_equal le("2"), p
-    assert_equal "{2}", Tickly.to_tcl(p)
+    assert_equal e("2"), p
   end
 
   should "parse multiple ints and strings as a stack of subexpressions" do
-    assert_kind_of Tickly::LiteralExpr, P.parse('2 foo bar baz')
-    assert_equal le("2", "foo", "bar", "baz"), P.parse('2 foo bar baz')
+    assert_equal e("2", "foo", "bar", "baz"), P.parse('2 foo bar baz')
   end
   
   should "parse and expand a string in double quotes" do
     p = P.parse('"This is a string literal with spaces"')
-    assert_equal le("This is a string literal with spaces"), p
+    assert_equal e("This is a string literal with spaces"), p
     
     p = P.parse('"This is a string literal \"escaped\" with spaces"')
-    assert_equal le("This is a string literal \"escaped\" with spaces"), p
+    assert_equal e("This is a string literal \"escaped\" with spaces"), p
   end
   
   should "parse a string expression" do
-    p = P.parse("[1 2 3]")
-    assert_kind_of Tickly::LiteralExpr, p
-    assert_equal 1, p.length
-    assert_kind_of Tickly::StringExpr, p[0]
+    assert_equal e(se("1", "2", "3")),  P.parse("[1 2 3]")
   end
   
   should "parse multiple string expressions" do
     p = P.parse("[1 2 3] [3 4 5 foo]")
-    assert_equal le(se("1", "2", "3"), se("3", "4", "5", "foo")), p
+    assert_equal e(se("1", "2", "3"), se("3", "4", "5", "foo")), p
   end
   
-  should "parse multiline statements as literal expressions" do
+  def test_parse_multiline_statements_as_literal_expressions
     p = P.parse("2\n2")
-    assert_equal "{{2} {2}}", Tickly.to_tcl(p)
+    assert_equal e(e("2"), e("2")), p
   end
   
-  should 'parse expression' do
+  def test_parse_expr
     expr = '{4 + 5}'
     p = P.parse(expr)
-    assert_equal le(le("4", "+", "5")), p
+    assert_equal e(le("4", "+", "5")), p
   end
   
-  should 'parse a Nuke node' do
+  def test_parsing_a_nuke_node
     f = File.open(File.dirname(__FILE__) + "/test-data/nukenode.txt")
     p = P.parse(f)
-    script = le(
-      le("set", "cut_paste_input", se("stack", "0")),
-      le("version", "6.3", "v4"),
-      le("push", "$cut_paste_input"),
-      le("Blur",
+    script = e(
+      e("set", "cut_paste_input", se("stack", "0")),
+      e("version", "6.3", "v4"),
+      e("push", "$cut_paste_input"),
+      e("Blur",
         le(
-          le("size", 
+          e("size", 
             le(
               le("curve", "x1", "0", "x20", "1.7", "x33", "3.9")
             )
           ),
-          le("name", "Blur1"),
-          le("label", "With \"Escapes\""),
-          le("selected", "true"),
-          le("xpos", "-353"),
-          le("ypos", "-33")
+          e("name", "Blur1"),
+          e("label", "With \"Escapes\""),
+          e("selected", "true"),
+          e("xpos", "-353"),
+          e("ypos", "-33")
         )
       )
     )
@@ -81,54 +74,54 @@ class TestParser < Test::Unit::TestCase
     f = File.open(File.dirname(__FILE__) + "/test-data/three_nodes_and_roto.txt")
     p = P.parse(f)
     # Should pass through the rotopaint node and get to the blur properly
-    blur = le("Blur", 
+    blur = e("Blur", 
       le(
-        le("size", 
+        e("size", 
           le(
             le("curve", "i", "x1", "0", "x20", "1.7", "x33", "3.9")
             )
           ),
-        le("name", "Blur1"),
-        le("label", "With \"Escapes\""),
-        le("selected", "true"),
-        le("xpos", "-212"),
-        le("ypos", "-24")
+        e("name", "Blur1"),
+        e("label", "With \"Escapes\""),
+        e("selected", "true"),
+        e("xpos", "-212"),
+        e("ypos", "-24")
       )
     )
     assert_equal blur, p[4]
   end
   
-  should 'parse a Nuke script with indentations' do
+  def test_parsing_nuke_script_with_indentations
     f = File.open(File.dirname(__FILE__) + "/test-data/nuke_group.txt")
     p = P.parse(f)
-    grp = le(
-      le("set", "cut_paste_input", se("stack", "0")),
-      le("version", "6.3", "v4"),
-      le("Group",
+    grp = e(
+      e("set", "cut_paste_input", se("stack", "0")),
+      e("version", "6.3", "v4"),
+      e("Group",
         le(
-          le("inputs", "0"),
-          le("name", "Group1"),
-          le("selected", "true")
+          e("inputs", "0"),
+          e("name", "Group1"),
+          e("selected", "true")
           )
         ),
-      le("CheckerBoard2",
+      e("CheckerBoard2",
         le(
-          le("inputs", "0"),
-          le("name", "CheckerBoard1")
+          e("inputs", "0"),
+          e("name", "CheckerBoard1")
         )
       ),
-      le("Blur",
+      e("Blur",
         le(
-          le("size", "42.5"),
-          le("name", "Blur1")
+          e("size", "42.5"),
+          e("name", "Blur1")
         )
       ),
-      le("Output",
+      e("Output",
         le(
-          le("name", "Output1")
+          e("name", "Output1")
         )
       ),
-      le("end_group")
+      e("end_group")
     )
     assert_equal grp, p
   end
@@ -136,9 +129,9 @@ class TestParser < Test::Unit::TestCase
   def test_one_node_parsing
     f = File.open(File.dirname(__FILE__) + "/test-data/one_node_with_one_param.txt")
     p = P.parse(f)
-    ref = le("SomeNode",
+    ref = e("SomeNode",
         le(
-          le("foo", "bar")
+          e("foo", "bar")
         )
     )
     

data/tickly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "tickly"
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Julik Tarkhanov"]
-  s.date = "2013-03-11"
+  s.date = "2013-03-12"
   s.description = "Parses the subset of the TCL grammar needed for Nuke scripts"
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
     "Rakefile",
     "lib/tickly.rb",
     "lib/tickly/evaluator.rb",
+    "lib/tickly/node_extractor.rb",
     "lib/tickly/parser.rb",
     "test/helper.rb",
     "test/test-data/nuke7_tracker_2tracks.nk",
@@ -37,8 +38,8 @@ Gem::Specification.new do |s|
     "test/test-data/tracker_with_differing_gaps.nk",
     "test/test-data/tracker_with_repeating_gaps.nk",
     "test/test_evaluator.rb",
+    "test/test_node_extractor.rb",
     "test/test_parser.rb",
-    "test/test_split_array.rb",
     "tickly.gemspec"
   ]
   s.homepage = "http://github.com/julik/tickly"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tickly
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 Z
+date: 2013-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
@@ -91,6 +91,7 @@ files:
 - Rakefile
 - lib/tickly.rb
 - lib/tickly/evaluator.rb
+- lib/tickly/node_extractor.rb
 - lib/tickly/parser.rb
 - test/helper.rb
 - test/test-data/nuke7_tracker_2tracks.nk
@@ -103,8 +104,8 @@ files:
 - test/test-data/tracker_with_differing_gaps.nk
 - test/test-data/tracker_with_repeating_gaps.nk
 - test/test_evaluator.rb
+- test/test_node_extractor.rb
 - test/test_parser.rb
-- test/test_split_array.rb
 - tickly.gemspec
 homepage: http://github.com/julik/tickly
 licenses:
@@ -121,7 +122,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 592217362083330592
+      hash: -2196296843243875248
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/test/test_split_array.rb

@@ -1,28 +0,0 @@
-require 'helper'
-
-class TestSplitArray < Test::Unit::TestCase
-  should "return a standard array unscathed" do
-    assert_equal [1, 2, 3, 4], Tickly.split_array([1,2,3,4])
-  end
-  
-  should "return a split array on nil" do
-    assert_equal [[1, 2],  [3, 4]], Tickly.split_array([1, 2, nil,  3, 4])
-  end
-  
-  should "only generate sub-elements where they make sense" do
-    assert_equal [[1, 2]], Tickly.split_array([nil, 1, 2, nil])
-  end
-  
-  class Jock < Array; end
-  
-  should "properly use subclasses" do
-    s =  Tickly.split_array(Jock.new([1, 2, nil,  3, 4]))
-    assert_kind_of Jock, s
-    assert_kind_of Jock, s[0]
-  end
-  
-  should 'squeeze nils out' do
-    s = Tickly.singularize_nils_in([nil, nil, 1,2,3,4, nil, nil, 456, nil, 9,nil,nil])
-    assert_equal [nil, 1,2,3,4, nil, 456, nil, 9, nil], s
-  end
-end