code-ruby 0.10.4 → 0.12.0

data/lib/code/node/right_operation.rb

@@ -6,23 +6,22 @@ class Code
       EQUAL = "="
 
       def initialize(parsed)
-        @left = Statement.new(parsed.delete(:left))
-        @operator = parsed.delete(:operator)
-        @right = Statement.new(parsed.delete(:right))
-
-        super(parsed)
+        return if parsed.blank?
+        @left = Statement.new(parsed.delete(:left).presence)
+        @operator = parsed.delete(:operator).presence
+        @right = Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
         case @operator
         when "if"
-          if @right.evaluate(**args).truthy?
-            @left.evaluate(**args)
+          if (@right&.evaluate(**args) || Object::Nothing.new).truthy?
+            @left&.evaluate(**args) || Object::Nothing.new
           else
             Object::Nothing.new
           end
         when "unless"
-          if @right.evaluate(**args).truthy?
+          if (@right&.evaluate(**args) || Object::Nothing.new).truthy?
             Object::Nothing.new
           else
             @left.evaluate(**args)
@@ -30,24 +29,28 @@ class Code
         when "while"
           left = Object::Nothing.new
 
-          left = @left.evaluate(**args) while @right.evaluate(**args).truthy?
+          while (@right&.evaluate(**args) || Object::Nothing.new).truthy?
+            left = @left&.evaluate(**args) || Object::Nothing.new
+          end
 
           left
         when "until"
           left = Object::Nothing.new
 
-          left = @left.evaluate(**args) while @right.evaluate(**args).falsy?
+          while (@right&.evaluate(**args) || Object::Nothing.new).falsy?
+            left = @left&.evaluate(**args) || Object::Nothing.new
+          end
 
           left
         when "rescue"
           begin
-            @left.evaluate(**args)
+            @left&.evaluate(**args) || Object::Nothing.new
           rescue Error
-            @right.evaluate(**args)
+            @right&.evaluate(**args) || Object::Nothing.new
           end
         when /=$/
-          right = @right.evaluate(**args)
-          left = @left.resolve(**args)
+          right = @right&.evaluate(**args) || Object::Nothing.new
+          left = @left&.resolve(**args) || Object::Nothing.new
 
           left.call(
             operator: @operator,
@@ -55,8 +58,8 @@ class Code
             **args
           )
         else
-          right = @right.evaluate(**args)
-          left = @left.evaluate(**args)
+          right = @right&.evaluate(**args) || Object::Nothing.new
+          left = @left&.evaluate(**args) || Object::Nothing.new
 
           left.call(
             operator: @operator,

data/lib/code/node/splat.rb

@@ -4,13 +4,17 @@ class Code
   class Node
     class Splat < Node
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        @right = Node::Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+        if @right
+          @right.evaluate(**args).call(operator: @operator, **args)
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/square_bracket.rb

@@ -4,29 +4,26 @@ class Code
   class Node
     class SquareBracket < Node
       def initialize(parsed)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @statements =
-          parsed
-            .delete(:statements)
-            .map { |statement| Node::Statement.new(statement) }
-
-        super(parsed)
+        return if parsed.blank?
+        @left = Node::Statement.new(parsed.delete(:left).presence)
+        @statements = parsed.delete(:statements).presence || []
+        @statements.map! { |statement| Node::Statement.new(statement) }
       end
 
       def evaluate(**args)
-        left = @left.evaluate(**args)
+        left = @left&.evaluate(**args) || Object::Nothing.new
 
-        @statements.reduce(left) do |object, statement|
+        (@statements || []).reduce(left) do |object, statement|
           object.code_fetch(statement.evaluate(**args))
         end
       end
 
       def resolve(**args)
-        left = @left.resolve(**args)
+        left = @left&.resolve(**args) || Object::Nothing.new
 
         list = Object::IdentifierList.new([left])
 
-        @statements.each do |statement|
+        (@statements || []).each do |statement|
           list.code_append(statement.evaluate(**args))
         end
 

data/lib/code/node/statement.rb

@@ -4,63 +4,63 @@ class Code
   class Node
     class Statement < Node
       def initialize(parsed)
+        return if parsed.blank?
+
         if parsed.key?(:nothing)
-          @statement = Node::Nothing.new(parsed.delete(:nothing))
+          @statement = Nothing.new(parsed.delete(:nothing))
         elsif parsed.key?(:boolean)
-          @statement = Node::Boolean.new(parsed.delete(:boolean))
+          @statement = Boolean.new(parsed.delete(:boolean))
         elsif parsed.key?(:group)
-          @statement = Node::Code.new(parsed.delete(:group))
+          @statement = Code.new(parsed.delete(:group))
         elsif parsed.key?(:call)
-          @statement = Node::Call.new(parsed.delete(:call))
+          @statement = Call.new(parsed.delete(:call))
         elsif parsed.key?(:number)
-          @statement = Node::Number.new(parsed.delete(:number))
+          @statement = Number.new(parsed.delete(:number))
         elsif parsed.key?(:string)
-          @statement = Node::String.new(parsed.delete(:string))
+          @statement = String.new(parsed.delete(:string))
         elsif parsed.key?(:list)
-          @statement = Node::List.new(parsed.delete(:list))
+          @statement = List.new(parsed.delete(:list))
         elsif parsed.key?(:dictionnary)
-          @statement = Node::Dictionary.new(parsed.delete(:dictionnary))
+          @statement = Dictionary.new(parsed.delete(:dictionnary))
         elsif parsed.key?(:chained_call)
-          @statement = Node::ChainedCall.new(parsed.delete(:chained_call))
+          @statement = ChainedCall.new(parsed.delete(:chained_call))
         elsif parsed.key?(:left_operation)
-          @statement = Node::LeftOperation.new(parsed.delete(:left_operation))
+          @statement = LeftOperation.new(parsed.delete(:left_operation))
         elsif parsed.key?(:right_operation)
-          @statement = Node::RightOperation.new(parsed.delete(:right_operation))
+          @statement = RightOperation.new(parsed.delete(:right_operation))
         elsif parsed.key?(:function)
-          @statement = Node::Function.new(parsed.delete(:function))
+          @statement = Function.new(parsed.delete(:function))
         elsif parsed.key?(:negation)
-          @statement = Node::Negation.new(parsed.delete(:negation))
+          @statement = Negation.new(parsed.delete(:negation))
         elsif parsed.key?(:power)
-          @statement = Node::Power.new(parsed.delete(:power))
+          @statement = Power.new(parsed.delete(:power))
         elsif parsed.key?(:unary_minus)
-          @statement = Node::UnaryMinus.new(parsed.delete(:unary_minus))
+          @statement = UnaryMinus.new(parsed.delete(:unary_minus))
         elsif parsed.key?(:ternary)
-          @statement = Node::Ternary.new(parsed.delete(:ternary))
+          @statement = Ternary.new(parsed.delete(:ternary))
         elsif parsed.key?(:rescue)
-          @statement = Node::Rescue.new(parsed.delete(:rescue))
+          @statement = Rescue.new(parsed.delete(:rescue))
         elsif parsed.key?(:not)
-          @statement = Node::Not.new(parsed.delete(:not))
+          @statement = Not.new(parsed.delete(:not))
         elsif parsed.key?(:if_modifier)
-          @statement = Node::IfModifier.new(parsed.delete(:if_modifier))
+          @statement = IfModifier.new(parsed.delete(:if_modifier))
         elsif parsed.key?(:if)
-          @statement = Node::If.new(parsed.delete(:if))
+          @statement = If.new(parsed.delete(:if))
         elsif parsed.key?(:while)
-          @statement = Node::While.new(parsed.delete(:while))
+          @statement = While.new(parsed.delete(:while))
         elsif parsed.key?(:splat)
-          @statement = Node::Splat.new(parsed.delete(:splat))
+          @statement = Splat.new(parsed.delete(:splat))
         elsif parsed.key?(:square_bracket)
-          @statement = Node::SquareBracket.new(parsed.delete(:square_bracket))
+          @statement = SquareBracket.new(parsed.delete(:square_bracket))
         end
-
-        super(parsed)
       end
 
       def evaluate(**args)
-        @statement.evaluate(**args)
+        @statement&.evaluate(**args) || Object::Nothing.new
       end
 
       def resolve(**args)
-        @statement.resolve(**args)
+        @statement&.resolve(**args) || Object::Nothing.new
       end
     end
   end

data/lib/code/node/string.rb

@@ -6,22 +6,25 @@ class Code
       class Part < Node
         class Code < Node
           def initialize(parsed)
-            @code = Node::Code.new(parsed)
+            return if parsed.blank?
+            @code = Node::Code.new(parsed.presence)
           end
 
           def evaluate(**args)
-            @code.evaluate(**args)
+            @code&.evaluate(**args) || Object::Nothing.new
           end
         end
 
         class Text < Node
           def initialize(parsed)
+            return if parsed.blank?
             @text = parsed
           end
 
           def evaluate(**_args)
             ::Code::Object::String.new(
               @text
+                .to_s
                 .gsub('\n', "\n")
                 .gsub('\r', "\r")
                 .gsub('\t', "\t")
@@ -34,29 +37,29 @@ class Code
         end
 
         def initialize(parsed)
+          return if parsed.blank?
+
           if parsed.key?(:text)
-            @part = Node::String::Part::Text.new(parsed.delete(:text))
+            @part = Node::String::Part::Text.new(parsed.delete(:text).presence)
           elsif parsed.key?(:code)
-            @part = Node::String::Part::Code.new(parsed.delete(:code))
+            @part = Node::String::Part::Code.new(parsed.delete(:code).presence)
           end
-
-          super(parsed)
         end
 
         def evaluate(**args)
-          @part.evaluate(**args)
+          @part&.evaluate(**args) || Object::Nothing.new
         end
       end
 
       def initialize(parsed)
-        parsed = [] if parsed == ""
-
-        @parts = parsed.map { |part| Node::String::Part.new(part) }
+        return if parsed.blank?
+        @parts =
+          (parsed.presence || []).map { |part| Node::String::Part.new(part) }
       end
 
       def evaluate(**args)
         ::Code::Object::String.new(
-          @parts.map { |part| part.evaluate(**args) }.map(&:to_s).join
+          (@parts || []).map { |part| part.evaluate(**args) }.map(&:to_s).join
         )
       end
     end

data/lib/code/node/ternary.rb

@@ -4,17 +4,17 @@ class Code
   class Node
     class Ternary < Node
       def initialize(parsed)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @middle = Node::Statement.new(parsed.delete(:middle))
-        @right = Node::Statement.new(parsed.delete(:right)) if parsed.key?(
-          :right
-        )
-        super(parsed)
+        return if parsed.blank?
+        @left = Node::Statement.new(parsed.delete(:left).presence)
+        @middle = Node::Statement.new(parsed.delete(:middle).presence)
+        if parsed.key?(:right)
+          @right = Node::Statement.new(parsed.delete(:right).presence)
+        end
       end
 
       def evaluate(**args)
-        if @left.evaluate(**args).truthy?
-          @middle.evaluate(**args)
+        if (@left&.evaluate(**args) || Object::Nothing.new).truthy?
+          @middle&.evaluate(**args) || Object::Nothing.new
         elsif @right
           @right.evaluate(**args)
         else

data/lib/code/node/unary_minus.rb

@@ -4,13 +4,17 @@ class Code
   class Node
     class UnaryMinus < Node
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        @right = Node::Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+        if @right
+          @right.evaluate(**args).call(operator: @operator, **args)
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/while.rb

@@ -8,12 +8,12 @@ class Code
       LOOP_KEYWORD = "loop"
 
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @statement = Statement.new(parsed.delete(:statement)) if parsed[
-          :statement
-        ]
-        @body = Code.new(parsed.delete(:body))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        if parsed.key?(:statement)
+          @statement = Statement.new(parsed.delete(:statement))
+        end
+        @body = Code.new(parsed.delete(:body).presence)
       end
 
       def evaluate(**args)
@@ -21,22 +21,24 @@ class Code
         when WHILE_KEYWORD
           last = Object::Nothing.new
 
-          last = @body.evaluate(**args) while @statement.evaluate(
-            **args
-          ).truthy?
+          while (@statement&.evaluate(**args) || Object::Nothing.new).truthy?
+            last = @body&.evaluate(**args) || Object::Nothing.new
+          end
 
           last
         when UNTIL_KEYWORD
           last = Object::Nothing.new
 
-          last = @body.evaluate(**args) while @statement.evaluate(**args).falsy?
+          while (@statement&.evaluate(**args) || Object::Nothing.new).falsy?
+            last = @body&.evaluate(**args) || Object::Nothing.new
+          end
 
           last
         when LOOP_KEYWORD
-          loop { @body.evaluate(**args) }
-          raise NotImplementedError
+          loop { @body&.evaluate(**args) || Object::Nothing.new }
+          Object::Nothing.new
         else
-          raise NotImplementedError, @operator
+          Object::Nothing.new
         end
       rescue Error::Break => e
         e.value || Object::Nothing.new

data/lib/code/node.rb

@@ -2,14 +2,8 @@
 
 class Code
   class Node
-    def initialize(parsed)
-      return if parsed.nil? || parsed.empty?
-
-      raise NotImplementedError, "#{self.class.name}: #{parsed.inspect}"
-    end
-
     def evaluate(**_args)
-      raise NotImplementedError, "#{self.class.name}#evaluate"
+      Object::Nothing.new
     end
 
     def resolve(...)

data/lib/code/object/argument.rb

@@ -5,9 +5,10 @@ class Code
     class Argument < Object
       attr_reader :value, :name
 
-      def initialize(value, name: nil)
-        @value = value
-        @name = name
+      def initialize(*args, **_kargs, &_block)
+        @value = args.first.presence || Nothing.new
+        @name = args.second.present? ? String.new(args.second) : nil
+        super
       end
 
       def keyword?

data/lib/code/object/boolean.rb

@@ -3,10 +3,11 @@
 class Code
   class Object
     class Boolean < ::Code::Object
-      attr_reader :raw
-
-      def initialize(raw)
-        @raw = (raw.is_a?(Object) ? raw.truthy? : !!raw)
+      def initialize(*args, **_kargs, &_block)
+        raw = args.first || Nothing.new
+        raw = raw.raw if raw.is_a?(Object)
+        @raw = !!raw
+        super
       end
 
       def self.name

data/lib/code/object/class.rb

@@ -3,11 +3,12 @@
 class Code
   class Object
     class Class < Object
-      attr_reader :raw
-
-      def initialize(raw)
+      def initialize(*args, **_kargs, &_block)
+        raw = args.first || Nothing.new
         raw = raw.raw if raw.is_a?(Class)
+        raw = raw.class if raw.is_an?(Object)
         @raw = raw
+        super
       end
 
       def call(...)

data/lib/code/object/code.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Code < Object
+      def initialize(*args, **_kargs, &_block)
+        raw = args.first.presence || Nothing.new
+        @raw = raw.is_a?(Node) ? raw : Node::Code.new(::Code.parse(raw.to_s))
+        super
+      end
+
+      def self.name
+        "Code"
+      end
+
+      def evaluate(...)
+        raw.evaluate(...)
+      end
+
+      def inspect
+        "code"
+      end
+
+      def to_s
+        "code"
+      end
+
+      def as_json(...)
+        "code".as_json(...)
+      end
+    end
+  end
+end

data/lib/code/object/context.rb

@@ -5,10 +5,12 @@ class Code
     class Context < Dictionary
       attr_reader :parent
 
-      def initialize(raw = {}, parent: nil)
-        raw = raw.raw if raw.is_a?(Dictionary)
+      def initialize(*args, **_kargs, &_block)
+        raw = args.first || Dictionary.new
+        raw = raw.raw if raw.is_a?(Object)
         @raw = raw.to_h
-        @parent = parent
+        @parent = Context.new(args.second) if args.second
+        super
       end
 
       def self.name
@@ -21,12 +23,12 @@ class Code
         elsif parent?
           parent.lookup!(identifier)
         else
-          raise Code::Error::Undefined, "#{identifier} is not defined"
+          raise Error::Undefined, "#{identifier} is not defined"
         end
       end
 
       def merge(other)
-        Context.new(raw.merge(other.raw), parent: parent || other.parent)
+        Context.new(raw.merge(other.raw), parent || other.parent)
       end
 
       def parent?

data/lib/code/object/date.rb

@@ -3,11 +3,12 @@
 class Code
   class Object
     class Date < Object
-      attr_reader :raw
-
-      def initialize(date)
-        date = date.raw if date.is_a?(Date)
-        @raw = date.to_date
+      def initialize(*args, **_kargs, &_block)
+        raw = args.map(&:to_s).join("-").presence || ::Date.current.to_s
+        @raw = ::Date.parse(raw)
+        super
+      rescue ::Date::Error
+        raise Error, "#{raw.inspect} is an invalid date"
       end
 
       def self.name
@@ -21,14 +22,38 @@ class Code
         when "tomorrow"
           sig(args)
           code_tomorrow
+        when "yesterday"
+          sig(args)
+          code_yesterday
+        when "today"
+          sig(args)
+          code_today
+        when "now"
+          sig(args)
+          code_now
         else
           super
         end
       end
 
+      def self.code_now
+        ::Time.zone ||= Time::DEFAULT_ZONE
+        new(::Time.zone.now.beginning_of_day)
+      end
+
+      def self.code_today
+        ::Time.zone ||= Time::DEFAULT_ZONE
+        new(::Time.zone.now.beginning_of_day)
+      end
+
       def self.code_tomorrow
         ::Time.zone ||= Time::DEFAULT_ZONE
-        new(::Time.zone.tomorrow)
+        new(::Time.zone.tomorrow.beginning_of_day)
+      end
+
+      def self.code_yesterday
+        ::Time.zone ||= Time::DEFAULT_ZONE
+        new(::Time.zone.yesterday.beginning_of_day)
       end
 
       def inspect