nrser 0.1.4 → 0.2.0.pre.0

data/lib/nrser/types/type.rb

@@ -25,15 +25,16 @@ module NRSER::Types
     #   default generated name.
     # 
     # @param [nil | #call] from_s:
-    #   Callable that will be passed a {String} and should return an object 
+    #   Callable that will be passed a {String} and should return an object
     #   that satisfies the type if it possible to create one.
     #   
-    #   The returned value *will* be checked against the type, so returning a 
+    #   The returned value *will* be checked against the type, so returning a
     #   value that doesn't satisfy will result in a {TypeError} being raised
     #   by {#from_s}.
     # 
     # @param [nil | #call | #to_proc] to_data:
-    #   
+    #   Optional callable (or object that responds to `#to_proc` so we can
+    #   get a callable) to call to turn type members into "data".
     # 
     def initialize name: nil, from_s: nil, to_data: nil, from_data: nil
       @name = name
@@ -89,6 +90,15 @@ module NRSER::Types
       self.class.short_name
     end
     
+    
+    # See if a value satisfies the type.
+    # 
+    # @param [Object] value
+    #   Value to test for type satisfaction.
+    # 
+    # @return [Boolean]
+    #   `true` if the `value` satisfies the type.
+    # 
     def test value
       raise NotImplementedError
     end
@@ -110,7 +120,7 @@ module NRSER::Types
     end
     
     
-    # Overridden to customize behavior for the {#from_s} and {#to_data} 
+    # Overridden to customize behavior for the {#from_s} and {#to_data}
     # methods - those methods are always defined, but we have {#respond_to?}
     # return `false` if they lack the underlying instance variables needed
     # to execute.
@@ -158,13 +168,13 @@ module NRSER::Types
     # @raise [NoMethodError]
     #   If this type doesn't know how to load values from strings.
     #   
-    #   In basic types this happens when {NRSER::Types::Type#initialize} was 
+    #   In basic types this happens when {NRSER::Types::Type#initialize} was
     #   not provided a `from_s:` {Proc} argument.
     #   
     #   {NRSER::Types::Type} subclasses may override {#from_s} entirely,
     #   divorcing it from the `from_s:` constructor argument and internal
     #   {@from_s} instance variable (which is why {@from_s} is not publicly
-    #   exposed - it should not be assumed to dictate {#from_s} behavior 
+    #   exposed - it should not be assumed to dictate {#from_s} behavior
     #   in general).
     # 
     # @raise [TypeError]
@@ -200,7 +210,7 @@ module NRSER::Types
     
     
     # Test if the type has custom information about how to convert it's values
-    # into "data" - structures and values suitable for transportation and 
+    # into "data" - structures and values suitable for transportation and
     # storage (JSON, etc.).
     # 
     # If this method returns `true` then {#to_data} should succeed.
@@ -244,7 +254,7 @@ module NRSER::Types
     #   by some back-ticks to make it easy to see where it starts and stops.
     # 
     def to_s
-      "`#{ name }`"
+      "{ x ∈ #{ name } }"
     end
     
     
@@ -266,5 +276,18 @@ module NRSER::Types
     alias_method :builtin_inspect, :inspect
     alias_method :inspect, :to_s
     
+    
+    # Hook into Ruby's *case subsumption* operator to allow usage in `case`
+    # statements!
+    # 
+    # TODO  Want to switch {NRSER::Types.match} over to use `===`!
+    # 
+    # @param value (see #test)
+    # @return (see #test)
+    #   
+    def === value
+      test value
+    end
+    
   end # Type
-end # NRSER::Types
+end # NRSER::Types

data/lib/nrser/types/when.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Refinements
+# =======================================================================
+
+
+# Declarations
+# =======================================================================
+
+
+# Definitions
+# =======================================================================
+
+module NRSER::Types
+  
+  class When < Type
+    
+    
+    # The wrapped {Object} whose `#===` will be used to test membership.
+    # 
+    # @return [Object]
+    #     
+    attr_reader :object
+    
+    
+    # Constructor
+    # ======================================================================
+    
+    # Instantiate a new `NRSER::Types::When`.
+    def initialize object, **options
+      super **options
+      @object = object
+    end # #initialize
+    
+    
+    # Instance Methods
+    # ======================================================================
+    
+    def test value
+      @object === value
+    end
+    
+    
+    def default_name
+      @object.to_s
+    end
+    
+    # If {#object} responds to `#from_data`, call that and check results.
+    # 
+    # Otherwise, forward up to {NRSER::Types::Type#from_data}.
+    # 
+    # @param [Object] data
+    #   Data to create the value from that will satisfy the type.
+    # 
+    # @return [Object]
+    #   Instance of {#object}.
+    # 
+    def from_data data
+      if @from_data.nil?
+        if @object.respond_to? :from_data
+          check @object.from_data( data )
+        else
+          super data
+        end
+      else
+        @from_data.call data
+      end
+    end
+    
+    
+    def has_from_data?
+      @from_data || @object.respond_to?( :from_data )
+    end
+    
+    
+    def == other
+      equal?( other ) ||
+      ( self.class == other.class &&
+        self.object == other.object )
+    end
+    
+  end # class When
+  
+  
+  def self.when value, **options
+    When.new value, **options
+  end
+  
+end # module NRSER::Types

data/lib/nrser/version.rb

@@ -18,7 +18,7 @@ module NRSER
   # 
   # @return [String]
   # 
-  VERSION = "0.1.4"
+  VERSION = "0.2.0.pre.0"
   
   
   module Version

data/spec/lib/nrser/mean_streak/design_spec.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+describe_spec_file(
+  spec_path: __FILE__,
+  class: NRSER::MeanStreak,
+) do
+  
+  describe "Test instance (`*...*` => `<I>...</I>`, etc. replacements)" do
+    subject {
+      described_class.new do |ms|
+        ms.render_type :emph do |doc, node|
+          "<I>#{ doc.render_children( node ) }</I>"
+        end
+        
+        ms.render_type :strong do |doc, node|
+          "<B>#{ doc.render_children( node ) }</B>"
+        end
+        
+        ms.render_type :code do |doc, node|
+          "<C>#{ node.string_content }</C>"
+        end
+        
+        # ms.render_type :code do |doc, prev_node, source_before, node, source_after, next_node|
+        #   [
+        #     source_before.chomp( '`' ),
+        #     "C#{ node.string_content }/C",
+        #     source_after.lchomp( '`' ),
+        #   ]
+        # end
+      end
+    }
+  
+    describe_method :render do
+      it_behaves_like "function",
+        mapping: {
+          # No handled nodes
+          "Here I am" => "Here I am",
+          
+          # Simple `:emph`, `:strong` with just a text child
+          "Here *I* am" => "Here <I>I</I> am",
+          "**Here** *I* am" => "<B>Here</B> <I>I</I> am",
+          
+          # Nested `:emph` / `:strong`
+          "*Here **I** am*" => "<I>Here <B>I</B> am</I>",
+          
+          # `:code`
+          "Here `I` am" => "Here <C>I</C> am",
+          # At the start
+          "`Here I` am" => "<C>Here I</C> am",
+          # At the end
+          "Here `I am`" => "Here <C>I am</C>",
+          
+          # Some big ol' bytes
+          "北京东城东直门" => "北京东城东直门",
+          "北京*东城*东直门" => "北京<I>东城</I>东直门",
+          
+          # Nesty-messtys with `:code` blocks...
+          # 
+          # It turns out the way to include ` in inline code is to quote
+          # with more than the longest backtick run inside
+          # 
+          %{A string: ``"with `backticks` in it"``} =>
+            %{A string: <C>"with `backticks` in it"</C>}
+        }
+    end
+  end
+end

data/spec/lib/nrser/mean_streak/identity_instance_spec.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+describe_spec_file(
+  description: %{
+    {NRSER::MeanStreak} constructed with no `#render_type` handlers
+    
+    Should serves as an identity function, rendering the same markdown source
+    that it received.
+  },
+  spec_path: __FILE__,
+  class: NRSER::MeanStreak,
+) do
+  describe_instance do
+    describe_method :render do
+      describe_called_with "hey" do
+        it { is_expected.to eq "hey" }
+      end # called with "hey"
+    end
+  end
+end # describe_spec_file

data/spec/{nrser → lib/nrser}/meta/props/to_and_from_data_spec.rb

@@ -12,11 +12,14 @@ describe NRSER::Meta::Props do
   describe_section "to and from data" do
   # ========================================================================
     
+    non_empty_str = t.non_empty_str
+    unsigned = t.unsigned
+    
     before( :all ) {
-      @cat_class = Class.new( NRSER::Meta::Props::Base ) do
-        prop :name, type: t.non_empty_str
-        prop :breed, type: t.non_empty_str
-        prop :age, type: t.unsigned
+      Cat = @cat_class = Class.new( NRSER::Meta::Props::Base ) do
+        prop :name, type: non_empty_str
+        prop :breed, type: non_empty_str
+        prop :age, type: unsigned
         
         def self.name; 'Cat'; end
       end
@@ -31,14 +34,17 @@ describe NRSER::Meta::Props do
         cat_class = @cat_class
         
         @owner_class = Class.new( NRSER::Meta::Props::Base ) do
-          prop :name, type: t.non_empty_str
+          prop :name, type: non_empty_str
           
           prop :cat, type: cat_class
           
           def self.name; 'Owner'; end
         end
         
-        @cat = @cat_class.new name: "Hooty", breed: "American Shorthair", age: 2
+        @cat = @cat_class.new \
+          name: "Hooty",
+          breed: "American Shorthair",
+          age: 2
         
         @owner = @owner_class.new name: "Neil", cat: @cat
       }
@@ -47,20 +53,20 @@ describe NRSER::Meta::Props do
         expect( @cat_class ).to be_a Class
         expect( @cat_class.is_a? ::Class ).to be true
         expect( @cat_class.name ).to eq "Cat"
-        expect( t.make @cat_class ).to be_a NRSER::Types::IsA
+        expect( t.make @cat_class ).to be_a NRSER::Types::When
         
         name_prop = @owner_class.props[:name]
-        expect( name_prop.type ).to be t.non_empty_str
+        expect( name_prop.type ).to be non_empty_str
         
         cat_prop = @owner_class.props[:cat]
-        expect( cat_prop.type ).to be_a NRSER::Types::IsA
-        expect( cat_prop.type.klass ).to be @cat_class
+        expect( cat_prop.type ).to be_a NRSER::Types::When
+        expect( cat_prop.type.object ).to be @cat_class
         expect( @cat_class.respond_to? :from_data ).to be true
         expect( cat_prop.type.has_from_data? ).to be true
       end
       
       it "dumps to and loads from data" do
-        data = @owner.to_data        
+        data = @owner.to_data
         restored = @owner_class.from_data data
         expect( restored.to_data ).to eq data
       end