uga_uga 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e475b295a76d004debe5c9f8b5f1ce5bb44b0af
-  data.tar.gz: eccdc212ac1896218ad9491fee0b8754694c5703
+  metadata.gz: aa553dc1ddf1359cba861ec14ad679a176b3f106
+  data.tar.gz: 79285eccf41f266a17c753a30bdb0ba793ec4a32
 SHA512:
-  metadata.gz: 00f18ca1b2ada9fefcdae9a6a860ea46fd1cd14678ffaa1142c4ed0a07f114571a138d2ee54c9e2bbe48180c80c7caa917803c74add98c18585be4e2fdad35d7
-  data.tar.gz: 348bd55a6fcce453c15e138fdfb0b97895c8b6fc3ef6da858787430675664d4ba2085c0566fbc6e5984ad7061d8f43ee625e74bdbff3cdff061936bd7ddb0532
+  metadata.gz: c225b4ac370606899e767fee6f0fb8f428221590cdded199eebf54f3f15aad1c08e098f7ef89e3144472c888a01c35cc465f5de12ea48759384e1e9a16ec57a1
+  data.tar.gz: ed779bb2f65c9d0b6ebb5fec31e460f3efb21a5235497aee2aa4e009f010a9ff5068ce51836d300d2afa90fce606be3ef192ef527abe05f3bbb37f72de5e9a13

data/README.md

@@ -2,7 +2,10 @@
 # Uga\_Uga
 
 Don't use this.
-Use [Treetop](https://github.com/nathansobo/treetop) or [OMeta](https://github.com/alexwarth/ometa-js).
+Use [Parslet](http://kschiess.github.io/parslet/) or [OMeta](https://github.com/alexwarth/ometa-js).
+
+Here is a video on creating your own external DSL:
+[Writing DSL's with Parslet by Jason Garber](https://www.youtube.com/watch?v=ET_POMJNWNs)
 
 ## Installation
 
@@ -22,30 +25,25 @@ Use [Treetop](https://github.com/nathansobo/treetop) or [OMeta](https://github.c
 
   results = []
 
-  Uga_Uga.uga code do |name, blok|
-
-    case name
+  Uga_Uga.new code do
 
-    when "bobby"
-      results << "bobby was called"
-      blok
+    case
 
-    when "howie"
-      results << "howie was called"
-      blok
+    when rex?("(white*)(word) { ")
+      line = shift
+      results << "#{captures.last} was called"
+      {:raw=>grab_until(bracket(line, '}'))}
 
-    when "mandel"
-      results << "mandel was called"
-      blok
-
-    when ":funny", '"comedian"'
+    when rex?(" (word) { (...) } ")
+      results << "#{captures.first} called with #{captures.last}"
 
     else
-      fail ArgumentError, "Command not found: #{name.inspect}"
-    end
+      fail ArgumentError, "Command not found: #{l!.inspect}"
+
+    end # === case name
 
-  end
+  end # === .new
 
-  puts results.inspect
+  results
 
 ```

data/VERSION

@@ -1 +1 @@
-0.1.0
+1.0.0

data/bin/uga_uga

@@ -2,10 +2,14 @@
 # -*- bash -*-
 #
 #
-set -u -e -o pipefail
 
 action="$1"
 shift
+set -u -e -o pipefail
+
+if [[ -z "$action" ]]; then
+  action="watch"
+fi
 
 case "$action" in
 
@@ -13,6 +17,7 @@ case "$action" in
     echo " ====================================================="
     echo ""
     echo " $  uga_uga   watch"
+    echo " $  uga_uga   watch  [test args]"
     echo ""
     echo " $  uga_uga   test"
     echo " $  uga_uga   test   name"
@@ -35,7 +40,7 @@ case "$action" in
 
       if [[ ( ! "$op" =~ "NOWRITE" ) && ( "$op" =~ "CLOSE" || "$op" =~ "WRITE" )  && ! -z "$file" ]]
       then
-        echo ""
+
         if [[ "$file" == *.js* ]]; then
           echo ""
           echo "=== Runninig jshint on $path: $CHANGE"
@@ -48,10 +53,17 @@ case "$action" in
           exec $path "watch" "$@"
         fi
 
-        if [[ "$file" == *.rb* || "$path" == *spec* ]]; then
-          echo "=== Running tests: $@"
-          bin/uga_uga test "$@" || true
+        if [[ "$path" == */explore.rb* ]]; then
+          cmd="bundle exec ruby "$path""
+          echo "=== $cmd"
+          $cmd || true
+        else
+          if [[ "$file" == *.rb* || "$file" == *.md* || "$path" == *spec* ]]; then
+            echo "=== Running tests: $@"
+            bin/uga_uga test "$@" || true
+          fi
         fi
+
       fi # === if file op
 
     done

data/lib/uga_uga.rb

@@ -1,47 +1,22 @@
 
 class Uga_Uga
 
-  class << self
-
-    def uga origin
-      tokens = blockenize(tokenize(origin))
+  NEW_LINE_REGEXP = /\n/
+  NOTHING         = ''.freeze
+  REX             = /(\ {1,})|\(([^\)]+)\)|(.)/
+  REX_CACHE       = {}
+  ZERO_OR_MORE_SPACES = /\ */
+  ONE_OR_MORE_SPACES  = /\ +/
 
-      case
-      when block_given?
-        run(tokens) do |cmd, block|
-          yield cmd, block
-        end
-      else
-        tokens
+  module String_Refines
+    refine String do
+      def blank?
+        strip.empty?
       end
     end
+  end
 
-    def tokenize origin
-      origin.split(/(\n)|((?<!\{)\{(?!\{))|((?<!\})\}(?!\}))/)
-    end
-
-    def blockenize raw
-      tokens  = raw.dup
-      final   = []
-      stack   = []
-      current = final
-      last    = nil
-      while t = tokens.shift
-        case t
-        when '{'
-          stack << current
-          current << (b = [])
-          current = b
-        when '}'
-          current = stack.pop
-        when ''
-          # ignore
-        else
-          current << t
-        end
-      end # === while
-      final
-    end
+  class << self
 
     #
     # This method is used mainly used in
@@ -66,33 +41,260 @@ class Uga_Uga
       end
     end
 
-    def run raw
-      arr = raw.dup
-      while t = arr.shift
+    def reg_exp str, *custom
+      i = -1
+      base = str.scan(REX).map { |arr|
         case
+        when arr[0]
+          ONE_OR_MORE_SPACES
+
+        when arr[1]
+          key = arr[1].strip
+
+          case key
+          when '...'
+            /\ *([^\)]+?)\ */
+
+          when '_'
+            i += 1
+            fail ArgumentError, "NO value set for #{i.inspect} -> #{str.inspect}" unless custom[i]
+            '(' + custom[i].to_s + ')'
+
+          when 'word'
+            /\ *([^\ \)]+)\ */
+
+          when 'white*'
+            /([\ ]*)/
+
+          when 'white'
+            /([\ ]+)/
+
+          when 'num'
+            /\ *([0-9\.\_\-]+)\ */
+
+          when /\A![^\!]+/
+            /\ *([^#{Regexp.escape key.sub('!', '')}]+)\ */
+
+          else
+            fail ArgumentError, "Unknown value for Regexp: #{arr[1].inspect} in #{str.inspect}"
+          end # === case key
 
-        when t.is_a?(String) && arr.first.is_a?(Array)
-          blok    = arr.shift
-          results = yield t.strip, blok
-          if results == blok
-            run results do |arg1, arg2|
-              yield  arg1, arg2
-            end
+        when arr[2]
+          Regexp.escape arr[2]
+
+        else
+          fail ArgumentError, "#{str.inspect} -> #{REG_EXP.inspect}"
+        end # === case
+      }
+
+      if base.first == ONE_OR_MORE_SPACES
+        base.shift
+        base.unshift ZERO_OR_MORE_SPACES
+      end
+
+      if base.last == ONE_OR_MORE_SPACES
+        base.pop
+        base.push ZERO_OR_MORE_SPACES
+      end
+
+      /\A#{base.join}\Z/
+    end
+
+  end # === class self ===
+
+  attr_reader :stack, :line_num, :parent, :captures
+  def initialize str_or_arr = nil, *args
+    @origin   = str_or_arr
+    @instruct = block_given? ? Proc.new : nil
+    @stack    = []
+
+    @captures      = nil
+    @parent        = nil
+    file_or_number = nil
+
+    args.each { |o|
+      case o
+      when Uga_Uga
+        @parent = o
+        file_or_number ||= o.line_num
+
+      when Numeric
+        file_or_number = o
+
+      when String
+        file_or_number = o
+
+      else
+        fail ArgumentError, "Unknown argument: #{o.inspect}"
+      end
+    }
+
+    return unless @origin
+
+    if str_or_arr.is_a?(String)
+      str    = str_or_arr
+      @lines = str_or_arr.split(NEW_LINE_REGEXP)
+    else
+      str    = nil
+      @lines = str_or_arr
+    end
+
+    @origin   = str_or_arr
+    @old      = []
+    @line_num = if file_or_number.is_a? Numeric
+                  file_or_number
+                else
+                  contents = File.read(file_or_number || __FILE__ )
+                  index    = contents.index(str || @lines.join("\n"))
+                  if index
+                    contents[0,index + 1].split("\n").size
+                  else
+                    1
+                  end
+                end
+    run
+  end # === def uga
+
+  def rex? str, *args
+    key     = [str,args].to_s
+    reg_exp = ( REX_CACHE[key] ||= Uga_Uga.reg_exp(str, *args) )
+    match = l!.match reg_exp
+    @captures = match ?
+                  match.captures :
+                  nil
+    !!match
+  end
+
+  def l!
+    @lines.first
+  end
+
+  private # ===============================================
+
+  def bracket l, close
+    index = l.index(/[^\ ]/)
+    "#{" " * index}#{close}"
+  end
+
+  def skip
+    throw :skip
+  end
+
+  def white?
+    l!.strip.empty?
+  end
+
+  def first *args
+    l!.split.first.split(*args).first.strip
+  end
+
+  def split *args
+    l!.split *args
+  end
+
+  def save_as cmd, data = nil
+    @stack.last[:type] = cmd
+    if data
+      @stack.<<( @stack.pop.merge(data) )
+    end
+    @stack.last
+  end
+
+  def shift
+    @old << @lines.shift
+    @line_num = @line_num + 1
+    @old.last
+  end
+
+  def head? str_or_rxp
+    rxp = if str_or_rxp.is_a?(String)
+            e = Regexp.escape str_or_rxp
+            /\A\ *#{e}/
+          else
+            str_or_rxp
           end
+    l![rxp]
+  end
 
-        when t.is_a?(String) && (arr.first != arr.is_a?(Array))
-          str = t.strip
-          if !str.empty?
-            yield str, nil
+  def tail? str_or_rxp
+    rxp = if str_or_rxp.is_a?(String)
+            e = Regexp.escape str_or_rxp
+            /#{e}\ *\z/
+          else
+            str_or_rxp
           end
+    l![rxp]
+  end
 
-        else
-          fail ArgumentError, "Syntax: #{t.inspect} in #{raw.join.inspect}"
+  def grab_all
+    blok = []
+    while !@lines.empty?
+      blok << shift
+    end
+
+    blok
+  end
 
+  def grab_all_or_until period
+    grab_until period, :close_optional
+  end
+
+  def grab_until period, *opts
+    new_cmd  = nil
+    blok     = []
+    found    = false
+    line_num = @line_num
+
+    is_line = period.is_a?(Regexp) ? period : /\A#{Regexp.escape period}\ *\Z/
+
+    while !found && (l = shift)
+      if !(found =l[is_line])
+        blok << l
+      end
+    end
+
+    if !found && !opts.include?(:close_optional)
+      fail ArgumentError, "Missing from around line number: #{line_num}: #{period.inspect}\n#{blok.join "\n"}"
+    end
+
+    blok
+  end
+
+  public def run *args
+    return(Uga_Uga.new(*args, &@instruct)) unless args.empty?
+    return @stack unless @stack.empty?
+
+    while !@lines.empty?
+      size = @lines.size
+      num = line_num
+      catch(:skip) do
+        result = instance_eval(&@instruct)
+        if result.is_a?(Hash)
+          @stack << result
+          @stack.last[:line_num] = num
         end
       end
-    end # === def run
+      shift if size == @lines.size
+    end
+
+    @stack.each { |h|
+      next if !h[:raw] || h[:done?]
+
+      if h[:type] == String
+        h[:output] = h[:raw].join("\n")
+        h.delete :raw
+        next
+      end
+
+      if h[:type] == Array
+        h[:output] = h[:raw]
+        h.delete :raw
+        next
+      end
+
+      h[:output] = Uga_Uga.new(h.delete(:raw), h[:line_num], self, &@instruct).stack
+    }
+  end # === def run
 
-  end # === class self ===
 
 end # === class Uga_Uga ===

data/specs/0000-it-runs.rb

@@ -1,14 +1,32 @@
 
+
 describe :uga.inspect do
 
   it "runs" do
-    o = Uga_Uga.uga(<<-EOF)
+    code = <<-EOF
       p {
         "my paragraph"
       }
     EOF
 
-    Uga_Uga.clean(o).should == [
+    o = Uga_Uga.new(code) do
+      case
+      when rex?(" (word) { ")
+        final = {
+          :type =>captures.first,
+          :raw  =>grab_until(bracket shift, '}')
+        }
+      when stack.empty?
+        final = {
+          :type=>String,
+          :output=>grab_all.join("\n")
+        }
+      else
+        fail ArgumentError, "Unknown common: #{l!}"
+      end
+    end
+
+    clean(o).should == [
       'p', ['"my paragraph"']
     ]
   end
@@ -19,20 +37,26 @@ describe :uga.inspect do
     code     = (contents[/```ruby([^`]+)```/] && $1).gsub('puts ','')
 
     result = eval(code, nil, file, contents.split("\n").index('```ruby') + 1)
-    result.should.match /bobby/
+
+    result.should == [
+      "bobby was called",
+      "howie called with :funny",
+      'mandel called with "comedian"'
+    ]
   end # === it
 
   it "parses lines without blocks" do
     code = <<-EOF
-      a :href => addr
-      a :href addr
+      a :href => addr /a
+      a :href addr    /a
       p { }
     EOF
 
-    Uga_Uga.clean(Uga_Uga.uga code).
-      should == [ "a :href => addr",
-                  "a :href addr",
-                  "p", []
+    clean(uga code).
+      should == [
+        :html, "a :href => addr /a",
+        :html, "a :href addr    /a",
+        :css, []
     ]
   end
 
@@ -45,42 +69,16 @@ describe :uga.inspect do
       }
     EOF
 
-    Uga_Uga.clean(Uga_Uga.uga code).
+    clean(uga code).
       should == [
-        "p", [
-          "span", [
-            "inner", ['"my"']
+        :css, [
+          :css, [
+            :css, ['"my"']
           ]
         ]
     ]
   end
 
-  it "yields the inner block" do
-    result = []
-    code = <<-EOF
-      p {
-        span {
-          1 {
-            2 {
-              3 { "my text" }
-            }
-          }
-        }
-      }
-    EOF
-
-    Uga_Uga.uga(code) do |cmd, code|
-      if cmd['"']
-        result << cmd
-      else
-        result << cmd.to_sym 
-      end
-      code
-    end
-
-    result.should == [:p, :span, :'1', :'2', :'3', '"my text"']
-  end # === it
-
   it "passes all text before a block start: cmd, cmd {" do
     result = []
     code = %^
@@ -89,49 +87,15 @@ describe :uga.inspect do
         }
       }
     ^
-    Uga_Uga.uga(code) do |cmd, code|
-      result << cmd
-      code
-    end
-    result.should == ["cmd, cmd", "inner, inner"]
-  end # === it
-
-  it "yields lines without a block" do
-    code = "
-      br /
-      br /
-      p { }
-    "
-    result = []
-    Uga_Uga.uga(code) do |cmd, code|
-      result << cmd
-      code
-    end
-
-    result.should == ['br /', 'br /', 'p']
-  end # === it
-
-  it "passes block w/original whitespace" do
-    blok = "
-         a 
-          a a
-          a
-    "
-    code = "
-      p {#{blok}}
-   "
-   result = nil
-   Uga_Uga.uga(code) { |cmd, code| result = code.join }
-   result.should == blok
+    uga(code).stack.first[:selectors]
+    .should == "cmd, cmd"
   end # === it
 
   it "does not parse mustaches as blocks: {{ }}" do
     code = "
-      p {{ code }}
+      p { {{code}} }
    "
-   result = nil
-   Uga_Uga.uga(code) { |cmd, code| result = cmd }
-   result.should == code.strip
+   clean(uga(code)).should == [:css, ['{{code}}']]
   end # === it
 
 end # === describe :uga

data/specs/lib/helpers.rb

@@ -3,3 +3,106 @@ require 'Bacon_Colored'
 require 'uga_uga'
 require 'pry'
 require 'awesome_print'
+
+module Bacon
+  class Context
+
+    def clean o
+      return o.strip if o.is_a?(String)
+      return o unless o.is_a?(Array) || o.is_a?(Uga_Uga)
+
+      return clean(o.stack) if o.respond_to?(:stack)
+
+      o.inject([]) do |memo, hash|
+        memo << hash[:type] unless hash[:type] == String
+        memo << clean(hash[:output])
+        memo
+      end
+    end
+
+    def uga *args
+      SAMPLE.run *args
+    end
+
+  end # === class Context
+
+end # === module Bacon
+
+
+SAMPLE = Uga_Uga.new do
+
+  skip if white?
+
+  case
+  when rex?("(white*)(...) { ")                    # === multi-line css
+    close = captures.first
+    shift
+    final = {
+      :type      => :css,
+      :selectors => captures.last,
+      :raw       => grab_until(/\A#{close}\}\ *\Z/)
+    }
+
+  when rex?(" (!{) {(...)} ")              # === css one-liner
+    selectors , content = captures
+    shift
+    final = {
+      :type      => :css,
+      :selectors => selectors,
+      :raw       => [content],
+      :one_liner => true
+    }
+
+  when rex?(" String (word) ")                   # === Multi-line String
+    close = captures.first
+    shift
+    final = {
+      :type   => String,
+      :output => grab_until(/\A\ *#{Regexp.escape close}\ *\Z/).join("\n")
+    }
+
+  when rex?(" color (word) ")
+    #  l![/\A\ *color\ *([a-zA-Z0-9\-\_\#]+)\ *\Z/]
+    val = captures.first
+    final = {
+      :type  => :css_property,
+      :name  => :color,
+      :output=> val
+    }
+
+  when rex?(" id (word) ")
+    #  l![/\A\ *id\ *([a-zA-Z0-9\-\_\#]+)\ *\Z/]
+    val = captures.first
+    final = {
+      :type  => :id!,
+      :output=> val
+    }
+
+  else
+    tag = first('.')
+    if tail?("/#{tag}")
+      {:type=>:html, :tag=>tag.to_sym, :one_liner=>true, :output => shift}
+    else
+      tag = tag.to_sym
+      case tag
+      when :p, :a
+        line    = shift
+        bracket = bracket(line, "/#{tag}")
+        final = {:type=>:html, :tag=>tag, :selector => line, :raw=>grab_until(bracket)}
+        final
+      else
+        if stack.empty?
+          {:type=>String, :raw=>grab_all}
+        elsif rex?(" (_) ", /\-{4,}/)     # Start of multi-line string --------------------
+          eos = l!.rstrip
+          shift
+          {:type=>String, :raw=>grab_all_or_until(/\A#{eos}\ *|Z/)}
+        else
+          fail ArgumentError, "Unknown command: #{line_num}: #{l!.inspect}"
+        end
+      end
+    end
+
+  end # === case
+
+end # === .new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uga_uga
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - da99
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-18 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry