publish_my_data 0.0.1

data/lib/publish_my_data/engine.rb

@@ -0,0 +1,9 @@
+module PublishMyData
+  class Engine < ::Rails::Engine
+    isolate_namespace PublishMyData
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+  end
+end

data/lib/publish_my_data/renderers.rb

@@ -0,0 +1,44 @@
+require "action_controller"
+
+# turtle
+Mime::Type.register("text/turtle", :ttl)
+ActionController::Renderers.add :ttl do |obj, opts|
+  str = obj.respond_to?(:to_ttl) ? obj.to_ttl : obj.to_s
+  send_data str, :type => Mime::TTL, :disposition => "inline"
+end
+
+#rdf
+Mime::Type.register("application/rdf+xml", :rdf)
+ActionController::Renderers.add :rdf do |obj, opts|
+  str = obj.respond_to?(:to_rdf) ? obj.to_rdf : obj.to_s
+  send_data str, :type => Mime::RDF, :disposition => "inline"
+end
+
+#ntriples
+# Note: We've elected not to respond with ntriples to text/plain as it confuses things
+# (text/plain is used for plain-text tabular sparql-select results!
+Mime::Type.register("application/n-triples", :nt )
+
+ActionController::Renderers.add :nt do |obj, opts|
+  str = obj.respond_to?(:to_nt) ? obj.to_nt : obj.to_s
+  send_data str, :type => Mime::NT, :disposition => "inline"
+end
+
+# re-register JSON with extra headers
+Mime::Type.unregister(:json)
+Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest application/sparql-results+json )
+# json already has a renderer
+
+# likewise for XML
+Mime::Type.unregister(:xml)
+Mime::Type.register "application/xml", :xml, %w( text/xml application/x-xml application/sparql-results+xml )
+# xml already has a renderer
+
+# text mime type and renderer already defined
+
+# csv mime type already registered.
+# csv (for sparql SELECT results)
+ActionController::Renderers.add :csv do |obj, opts|
+  str = obj.respond_to?(:to_csv) ? obj.to_csv : obj.to_s
+  send_data str, :type => Mime::CSV, :disposition => "inline"
+end

data/lib/publish_my_data/sparql_query.rb

@@ -0,0 +1,117 @@
+module PublishMyData
+
+  class SparqlQueryExecutionException < StandardError; end
+
+  class SparqlQuery < Tripod::SparqlQuery
+
+    attr_reader :request_format # symbol representing the format of the original request
+    attr_reader :parent_query # set if this query originated from another (e.g. pagination or count)
+
+    def initialize(query_string, request_format_symbol = :html, parent_query = nil)
+      super(query_string)
+      @parent_query = parent_query
+      @request_format = request_format_symbol
+    end
+
+    # executes the query, using the right format parameters (for fuseki) for the query type and request format
+    def execute
+      begin
+        case query_type
+          when :select
+            result_str = Tripod::SparqlClient::Query.select(self.query, select_format_str)
+          when :ask
+            result_str = Tripod::SparqlClient::Query.ask(self.query, ask_format_str)
+          when :construct
+            result_str = Tripod::SparqlClient::Query.construct(self.query, construct_or_describe_header)
+          when :describe
+            result_str = Tripod::SparqlClient::Query.describe(self.query, construct_or_describe_header)
+          else
+            raise SparqlQueryExecutionException.new("Unsupported Query Type. Please enter only SELECT, CONSTRUCT, DESCRIBE or ASK queries.")
+        end
+
+      rescue Tripod::Errors::BadSparqlRequest => bad_sparql
+        if self.parent_query
+          # call execute on the parent(this will fail too), but it means that we get the right error for
+          # the user-entered query
+          parent_query.execute
+        else
+          raise SparqlQueryExecutionException.new(process_sparql_parse_failed_exception_message(bad_sparql))
+        end
+      end
+
+      PublishMyData::SparqlQueryResult.new(result_str)
+    end
+
+    # make a pagination version and execute that.
+    def paginate(page, per_page, look_ahead=0)
+      self.as_pagination_query(page, per_page, look_ahead).execute
+    end
+
+    # return the number of results that this query returns
+    # (creates and executes a count query behind the scenes)
+    def count
+      result = JSON.parse(self.as_count_query.execute.to_s)["results"]["bindings"]
+      result[0][".1"]["value"].to_i
+    end
+
+    def allow_pagination?
+      self.query_type == :select
+    end
+
+    def as_count_query(format = :json)
+      # return the paginated version
+      PublishMyData::SparqlQuery.new(as_count_query_str, format, self) # pass in the original query
+    end
+
+    # for selects only, turn this into a paginated version. Returns a whole new SparqlQuery object.
+    def as_pagination_query(page, per_page, look_ahead=0)
+
+      check_subqueryable!
+
+      limit = per_page + look_ahead
+      offset = per_page * (page-1)
+      # wrap it in a subselect with limit and offset
+      paginated_query = "SELECT * { #{self.body} } LIMIT #{limit} OFFSET #{offset}"
+      # put the prefixes back on the start
+      paginated_query = "#{self.prefixes} #{paginated_query}" if self.prefixes
+
+      # return the paginated version
+      PublishMyData::SparqlQuery.new(paginated_query, self.request_format, self) # pass in the original query
+    end
+
+    private
+
+    def process_sparql_parse_failed_exception_message(bad_sparql_request)
+      message = bad_sparql_request.message
+      start = message.index(query) + query.size
+      finish = message.index('Fuseki')-1 || (message.length-1)
+      message[start..finish].strip
+    end
+
+    def select_format_str
+      if [:json, :csv, :xml, :text].include?(request_format)
+        self.request_format.to_s
+      else
+        'text'
+      end
+    end
+
+    def ask_format_str
+      if [:json, :xml, :text].include?(request_format)
+        self.request_format.to_s
+      else
+        'text'
+      end
+    end
+
+    def construct_or_describe_header
+      if [:nt, :ttl, :rdf].include?(request_format)
+        Mime::Type.lookup_by_extension( request_format.to_s )
+      else
+        Mime::NT
+      end
+    end
+
+  end
+
+end

data/lib/publish_my_data/sparql_query_result.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/numeric/bytes'
+
+module PublishMyData
+
+  class SparqlQueryResultTooLargeException < StandardError; end
+
+  # class to wrap up a string sparql result
+  class SparqlQueryResult
+
+    cattr_accessor :MAX_SIZE
+    @@MAX_SIZE = 4.megabytes
+
+    attr_reader :result_str
+
+    def initialize(result_str)
+      @result_str = result_str
+
+      if self.length > SparqlQueryResult.MAX_SIZE
+        raise SparqlQueryResultTooLargeException.new(self.length)
+      end
+
+    end
+
+    # responds to a bunch of to_x methods to help with rails responders /rendering.
+    def length
+      self.to_s.length
+    end
+
+    def to_s
+      self.result_str
+    end
+
+    [:csv, :nt, :ttl, :rdf, :text].each do |format|
+      define_method :"to_#{format.to_s}" do
+        self.to_s
+      end
+    end
+
+    def to_json(opts={})
+      to_s
+    end
+
+    def to_xml(opts={})
+      to_s
+    end
+
+  end
+
+end

data/lib/publish_my_data/version.rb

@@ -0,0 +1,3 @@
+module PublishMyData
+  VERSION = "0.0.1"
+end

data/lib/tasks/publish_my_data_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :publish_my_data do
+#   # Task goes here
+# end

data/spec/controllers/publish_my_data/datasets_controller_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+module PublishMyData
+  describe DatasetsController do
+
+    describe "#show" do
+
+      let(:dataset) { FactoryGirl.create(:my_dataset) }
+
+      shared_examples_for "dataset show" do
+
+        context "for an existing dataset" do
+          it "should respond successfully" do
+            get :show, id: dataset.slug, use_route: :publish_my_data, :format => format
+            response.should be_success
+          end
+
+          it "should set the types variable" do
+            get :show, id: dataset.slug, use_route: :publish_my_data, :format => format
+            assigns['types'].class.should == Tripod::ResourceCollection
+          end
+        end
+
+        context "with a non-existent dataset slug" do
+          it "should respond with not found" do
+            get :show, id: "slug-that-doesnt-exist", use_route: :publish_my_data, :format => format
+            response.should be_not_found
+          end
+        end
+      end
+
+      shared_examples_for "a non html format" do
+
+        context "for an existing dataset" do
+          it "should return the dataset dtls in that format" do
+            get :show, id: dataset.slug, use_route: :publish_my_data, :format => format
+            response.body.should == dataset.send("to_#{format}")
+          end
+        end
+
+        context "for a non-existent dataset slug" do
+          it "should return a blank body" do
+            get :show, id: "slug-that-doesnt-exist", use_route: :publish_my_data, :format => format
+            response.body.should be_blank
+          end
+        end
+      end
+
+      context "for rdf format" do
+        let(:format){ 'html' }
+        it_should_behave_like "dataset show"
+      end
+
+      context "for rdf format" do
+        let(:format){ 'rdf' }
+        it_should_behave_like "a non html format"
+        it_should_behave_like "dataset show"
+      end
+
+      context "for json format" do
+        let(:format){ 'json' }
+        it_should_behave_like "a non html format"
+        it_should_behave_like "dataset show"
+      end
+
+      context "for ttl format" do
+        let(:format){ 'ttl' }
+        it_should_behave_like "a non html format"
+        it_should_behave_like "dataset show"
+      end
+
+      context "for ntriples format" do
+        let(:format){ 'nt' }
+        it_should_behave_like "a non html format"
+        it_should_behave_like "dataset show"
+      end
+
+    end
+
+    describe "#index" do
+
+      # make some datasets
+      before do
+        (1..30).each do |i|
+          slug = i
+          uri = Dataset.uri_from_slug(slug)
+          graph = Dataset.metadata_graph_uri(slug)
+          d = PublishMyData::Dataset.new(uri, graph)
+          d.title = "Dataset #{i.to_s}"
+          d.theme = (i.even? ? 'theme' : 'othertheme')
+          d.save!
+        end
+      end
+
+      shared_examples_for "a dataset collection in non-html" do
+        it "should render the collection in the right format" do
+          get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
+          response.body.should == Dataset.all.limit(per_page).offset(offset).resources.send("to_#{format}")
+        end
+
+        it "shouldn't call Kaminari" do
+          Kaminari.should_not_receive(:paginate_array)
+          get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
+        end
+
+        it "should render successfully" do
+          get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
+          response.should be_success
+        end
+      end
+
+      shared_examples_for "dataset kaminari pagination" do
+        it "should call kaminari to paginate the results" do
+          datasets_array = Dataset.all.limit(per_page).offset(offset).resources.to_a
+          count = Dataset.count
+
+          kam = Kaminari.paginate_array(datasets_array, total_count: count)
+
+          Kaminari.should_receive(:paginate_array).with(datasets_array, total_count: count).and_return(kam)
+          kam.should_receive(:page).with(page).and_return(kam)
+          kam.should_receive(:per).with(per_page).and_return(kam)
+          get :index, page: page, per_page: per_page, use_route: :publish_my_data
+        end
+
+        it "should set @datasets with the right page of datasets" do
+          get :index, page: page, per_page: per_page, use_route: :publish_my_data
+          assigns['datasets'].map{ |d| d.uri.to_s }.should ==
+            Dataset.all.resources[offset...offset+per_page].map{ |d| d.uri.to_s }
+          assigns['datasets'].length.should == per_page
+        end
+
+      end
+
+      context 'with no pagination params' do
+        let(:page) {1}
+        let(:per_page) {20}
+        let(:offset) { (page-1)*per_page }
+
+        it "should retreive the first page of results" do
+          crit = Dataset.all
+          Dataset.should_receive(:all).at_least(:once).and_return(crit)
+          crit.should_receive(:limit).with(per_page).and_call_original
+          crit.should_receive(:offset).with(offset).and_call_original
+          get :index, use_route: :publish_my_data
+        end
+
+        context 'with html format' do
+          it_should_behave_like "dataset kaminari pagination"
+        end
+
+        context 'with non-html format' do
+          let(:format) {'rdf'}
+          it_should_behave_like "a dataset collection in non-html"
+        end
+      end
+
+      context 'with pagination params' do
+        let(:page) {3}
+        let(:per_page) {10}
+        let(:offset) { (page-1)*per_page }
+
+        it "should retreive the right page of results" do
+          crit = Dataset.all
+          Dataset.should_receive(:all).at_least(:once).and_return(crit)
+          crit.should_receive(:limit).with(per_page).and_call_original
+          crit.should_receive(:offset).with(offset).and_call_original
+          get :index, page: page, per_page: per_page, use_route: :publish_my_data
+        end
+
+        it_should_behave_like "dataset kaminari pagination"
+
+        context 'with non-html format' do
+          let(:format) {'ttl'}
+          it_should_behave_like "a dataset collection in non-html"
+        end
+      end
+
+      context "with a theme parameter" do
+        let(:theme) {'theme'}
+
+        it "should filter the results to only datasets in the theme" do
+          get :index, theme: theme, use_route: :publish_my_data
+          assigns['datasets'].length.should == 15 # only the even ones are in this theme
+        end
+      end
+
+    end
+
+  end
+end

data/spec/controllers/publish_my_data/resources_controller_spec.rb

@@ -0,0 +1,399 @@
+require 'spec_helper'
+
+module PublishMyData
+  describe ResourcesController do
+
+    describe "#id" do
+
+      context "with html mime type" do
+
+        before do
+          get :id, :path => "this/is/my/path", use_route: :publish_my_data
+        end
+
+        it "should redirect to the corresponding doc view with a 303" do
+          response.status.should eq(303)
+          response.should redirect_to "/doc/this/is/my/path"
+        end
+      end
+
+      context "with an alternative mime type passed in the header" do
+        before do
+          @request.env['HTTP_ACCEPT'] = "application/rdf+xml"
+          get :id, :path => "this/is/my/path", use_route: :publish_my_data
+        end
+
+        it "should keep that mime type when doing the 303" do
+          response.status.should eq(303)
+          response.should redirect_to "/doc/this/is/my/path"
+          response.content_type.should == Mime::RDF
+        end
+      end
+
+    end
+
+    describe "#doc" do
+
+      before do
+        @resource = FactoryGirl.create(:yuri_unicorn_resource)
+      end
+
+      it "should respond successfully" do
+        get :doc, :path => "unicorns/yuri", use_route: :publish_my_data
+        response.should be_success
+      end
+
+      it "should render the show template" do
+        get :doc, :path => "unicorns/yuri", use_route: :publish_my_data
+        response.should render_template("publish_my_data/resources/show")
+      end
+
+      context "for html" do
+        it "should eager load the labels" do
+          Resource.should_receive(:find).and_return(@resource)
+          @resource.should_receive(:eager_load_predicate_triples!)
+          @resource.should_receive(:eager_load_object_triples!)
+          get :doc, :path => "unicorns/yuri", use_route: :publish_my_data
+        end
+      end
+
+      context "with an alternative mime type passed in the header" do
+
+        before do
+          @request.env['HTTP_ACCEPT'] = "application/rdf+xml"
+          get :doc, :path => "unicorns/yuri", use_route: :publish_my_data
+        end
+
+        it "should resond with the right mime type" do
+          response.content_type.should == Mime::RDF
+        end
+
+        it "should respond with the right content" do
+          response.body.should == @resource.to_rdf
+        end
+
+        it "should not eager load the labels" do
+          Resource.should_receive(:find).and_return(@resource)
+          @resource.should_not_receive(:eager_load_predicate_triples!)
+          @resource.should_not_receive(:eager_load_object_triples!)
+          get :doc, :path => "unicorns/yuri", use_route: :publish_my_data
+        end
+
+        context "and the resource doesn't exist" do
+          it "should 404 with a blank response" do
+            get :doc, :path => "unicorns/borat", use_route: :publish_my_data
+            response.should be_not_found
+            response.body.should be_blank
+          end
+        end
+
+      end
+
+      context "with an alternative format passed on the url" do
+
+        it "should resond with the right mime type" do
+          get :doc, :path => "unicorns/yuri", format: 'ttl', use_route: :publish_my_data
+          response.content_type.should == Mime::TTL
+        end
+
+        it "should respond with the right content" do
+          get :doc, :path => "unicorns/yuri", format: 'ttl', use_route: :publish_my_data
+          response.body.should == @resource.to_ttl
+        end
+
+      end
+
+      context "when resource doesn't exist" do
+
+        before do
+          get :doc, :path => "doesnt/exist", use_route: :publish_my_data
+        end
+
+        it "should 404" do
+          response.should be_not_found
+        end
+
+      end
+
+    end
+
+    describe "#definition" do
+
+      before do
+        @resource = FactoryGirl.create(:mean_result)
+      end
+
+      context "for resource in our database" do
+
+        it "should respond successfully" do
+          get :definition, :path => "statistics/meanResult", use_route: :publish_my_data
+          response.should be_success
+        end
+
+        it "should render the doc template" do
+          get :definition, :path => "statistics/meanResult", use_route: :publish_my_data
+          response.should render_template("publish_my_data/resources/show")
+        end
+
+        context "with an alternative mime type" do
+          it "should with the right mime type and content" do
+            get :definition, :path => "statistics/meanResult", :format => 'nt', use_route: :publish_my_data
+            response.content_type.should == Mime::NT
+            response.body.should == @resource.to_nt
+          end
+        end
+
+      end
+
+      context "when resource doesn't exist" do
+        it "should 404" do
+          get :definition, :path => "statistics/nonExistent", use_route: :publish_my_data
+          response.should be_not_found
+        end
+      end
+
+    end
+
+    describe "#show" do
+
+      context "with a resource not in our database" do
+
+        uri = "http://purl.org/linked-data/sdmx/2009/dimension%23refArea"
+
+        context "html mime type" do
+
+          before do
+            get :show, :uri => uri, use_route: :publish_my_data
+          end
+
+          context "with resource not in our database" do
+            it "should redirect to the external uri" do
+              response.should redirect_to('http://purl.org/linked-data/sdmx/2009/dimension%23refArea')
+            end
+          end
+
+        end
+
+        context "non html mime type" do
+
+          before do
+            get :show, :uri => uri, :format => 'rdf', use_route: :publish_my_data
+          end
+
+          it "should 404" do
+            response.should be_not_found
+          end
+        end
+      end
+
+      context "with a resource in our database" do
+
+        before do
+          uri = 'http://uri'
+          graph = 'http://graph'
+          r = Resource.new(uri, graph)
+          r.write_predicate('http://foo', 'blah')
+          r.save!
+
+          get :show, :uri => r.uri, use_route: :publish_my_data
+        end
+
+        it "should respond succesfully" do
+          response.should be_success
+        end
+
+        it "should render the show template" do
+          response.should render_template("publish_my_data/resources/show")
+        end
+
+      end
+    end
+
+    describe "#index" do
+
+       shared_examples_for "resource kaminari pagination" do
+        it "should call kaminari to paginate the results" do
+          res_array = Resource.all.limit(per_page).offset(offset).resources.to_a
+          count = Resource.count
+
+          kam = Kaminari.paginate_array(res_array, total_count: count)
+
+          Kaminari.should_receive(:paginate_array).with(res_array, total_count: count).and_return(kam)
+          kam.should_receive(:page).with(page).and_return(kam)
+          kam.should_receive(:per).with(per_page).and_return(kam)
+          get :index, page: page, per_page: per_page, use_route: :publish_my_data
+        end
+
+        it "should set @resources with the right page of datasets" do
+          get :index, page: page, per_page: per_page, use_route: :publish_my_data
+          assigns['resources'].map{ |d| d.uri.to_s }.should ==
+            Resource.all.resources[offset...offset+per_page].map{ |r| r.uri.to_s }
+          assigns['resources'].length.should == per_page
+        end
+      end
+
+      shared_examples_for "a resource collection in non-html" do
+        it "should render the collection in the right format" do
+          get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
+          response.body.should == Resource.all.limit(per_page).offset(offset).resources.send("to_#{format}")
+        end
+
+        it "shouldn't call Kaminari" do
+          Kaminari.should_not_receive(:paginate_array)
+          get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
+        end
+
+        it "should render successfully" do
+          get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
+          response.should be_success
+        end
+      end
+
+      let(:dataset) { FactoryGirl.create(:my_dataset) }
+
+      let(:type) do
+        t = PublishMyData::RdfType.new('http://i-am-a-type', 'http://types')
+        t.label = 'I am a type'
+        t.save!
+        t
+      end
+
+      before do
+
+        # make some resources (in and out of our dataset and type)
+        (1..5).each do |i|
+          r = Resource.new("http://resource-in-ds/#{i}", dataset.data_graph_uri)
+          r.label = "resource #{i}"
+          r.write_predicate(RDF.type, RDF::URI.new(type.uri)) if i.even?
+          r.save!
+        end
+
+        (1..3).each do |i|
+          r = Resource.new("http://resource-not-in-ds/#{i}", 'http://anothergraph')
+          r.label = "resource #{i}"
+          r.write_predicate(RDF.type, RDF::URI.new(type.uri)) if i.even?
+          r.save!
+        end
+      end
+
+      it 'should set the resources variable' do
+        get :index, use_route: :publish_my_data
+        assigns['resources'].should_not be_blank
+      end
+
+      context "with no parameters" do
+        it "should respond successfully" do
+          get :index, use_route: :publish_my_data
+        end
+
+        it "should return paginated results for Resource.all" do
+          subject.should_receive(:paginate_resources).with(Resource.all).and_call_original
+          get :index, use_route: :publish_my_data
+          assigns['resources'].length.should == 10 # 8 resources, plus ds and type!
+        end
+      end
+
+      context 'with pagination params' do
+        let(:page) {2}
+        let(:per_page) {2}
+        let(:offset) { (page-1)*per_page }
+
+        it "should retreive the right page of results" do
+          crit = Resource.all
+          Resource.should_receive(:all).at_least(:once).and_return(crit)
+          crit.should_receive(:limit).with(per_page).and_call_original
+          crit.should_receive(:offset).with(offset).and_call_original
+          get :index, page: page, per_page: per_page, use_route: :publish_my_data
+        end
+
+        it_should_behave_like "resource kaminari pagination"
+
+        context 'with non-html format' do
+          let(:format) {'ttl'}
+          it_should_behave_like "a resource collection in non-html"
+        end
+      end
+
+      context 'with a type parameter' do
+        context 'where the type exists' do
+          before do
+            get :index, type_uri: type.uri, use_route: :publish_my_data
+          end
+
+          it 'should filter the results by things of that type' do
+             assigns['resources'].length.should == 3
+          end
+
+          it 'should set the type filter variable' do
+            assigns['type_filter'].should == type.uri
+          end
+
+          it 'should set the dataset variable to the dataset' do
+            assigns['type'].should == type
+          end
+        end
+
+        context 'where the type does not exist' do
+          before do
+            get :index, type_uri: 'bleh', use_route: :publish_my_data
+          end
+
+          it 'should not find any results' do
+            assigns['resources'].length.should == 0
+          end
+
+          it 'should set the type filter variable' do
+            assigns['type_filter'].should == 'bleh'
+          end
+
+          it 'should not set the type variable' do
+            assigns['type'].should be_nil
+          end
+        end
+      end
+
+      context "with a dataset parameter" do
+        context 'where the dataset exists' do
+
+          before do
+            get :index, dataset: dataset.slug, use_route: :publish_my_data
+          end
+
+          it "should filter the results by datasets with that slug" do
+            assigns['resources'].length.should == 5
+          end
+
+          it 'should set the dataset filter variable' do
+            assigns['dataset_filter'].should == dataset.slug
+          end
+
+          it 'should set the dataset variable to the dataset' do
+            assigns['dataset'].should == dataset
+          end
+
+        end
+
+        context 'where the dataset does not exist' do
+          before do
+            get :index, dataset: 'bleh', use_route: :publish_my_data
+          end
+
+          it 'should not find any results' do
+            assigns['resources'].length.should == 0
+          end
+
+          it 'should set the dataset filter variable' do
+            assigns['dataset_filter'].should == 'bleh'
+          end
+
+          it 'should not set the dataset variable to the dataset' do
+            assigns['dataset'].should be_nil
+          end
+        end
+      end
+    end
+
+
+
+  end
+end